From 4bd78c3f0c9f782a3f0179a0f27e6cb3f290a556 Mon Sep 17 00:00:00 2001 From: Ivan Gomes Date: Thu, 12 May 2022 10:33:58 -0400 Subject: [PATCH 1/2] ST5AS-199 Update to 2022-04 baseline --- app/controllers/ElementController.java | 2 +- app/controllers/RelationshipController.java | 2 +- app/dao/impl/jpa/JpaCommitDao.java | 6 +- app/dao/impl/jpa/JpaElementDao.java | 6 +- app/dao/impl/jpa/JpaRelationshipDao.java | 10 +- .../sysml/lifecycle/impl/package-info.java | 1 + .../sysml/metamodel/AcceptActionUsage.java | 5 +- .../omg/sysml/metamodel/ActionDefinition.java | 5 +- app/org/omg/sysml/metamodel/ActionUsage.java | 5 +- .../omg/sysml/metamodel/ActorMembership.java | 5 +- .../sysml/metamodel/AllocationDefinition.java | 5 +- .../omg/sysml/metamodel/AllocationUsage.java | 5 +- .../metamodel/AnalysisCaseDefinition.java | 5 +- .../sysml/metamodel/AnalysisCaseUsage.java | 5 +- .../sysml/metamodel/AnnotatingElement.java | 5 +- app/org/omg/sysml/metamodel/Annotation.java | 5 +- .../metamodel/AssertConstraintUsage.java | 5 +- .../metamodel/AssignmentActionUsage.java | 5 +- app/org/omg/sysml/metamodel/Association.java | 5 +- .../sysml/metamodel/AssociationStructure.java | 5 +- .../sysml/metamodel/AttributeDefinition.java | 5 +- .../omg/sysml/metamodel/AttributeUsage.java | 5 +- app/org/omg/sysml/metamodel/Behavior.java | 5 +- .../omg/sysml/metamodel/BindingConnector.java | 5 +- .../metamodel/BindingConnectorAsUsage.java | 5 +- .../sysml/metamodel/BooleanExpression.java | 5 +- .../metamodel/CalculationDefinition.java | 5 +- .../omg/sysml/metamodel/CalculationUsage.java | 5 +- .../omg/sysml/metamodel/CaseDefinition.java | 5 +- app/org/omg/sysml/metamodel/CaseUsage.java | 5 +- app/org/omg/sysml/metamodel/Class.java | 5 +- app/org/omg/sysml/metamodel/Classifier.java | 5 +- .../sysml/metamodel/CollectExpression.java | 5 +- app/org/omg/sysml/metamodel/Comment.java | 5 +- .../sysml/metamodel/ConcernDefinition.java | 5 +- app/org/omg/sysml/metamodel/ConcernUsage.java | 5 +- .../metamodel/ConjugatedPortDefinition.java | 5 +- .../sysml/metamodel/ConjugatedPortTyping.java | 5 +- app/org/omg/sysml/metamodel/Conjugation.java | 5 +- .../sysml/metamodel/ConnectionDefinition.java | 5 +- .../omg/sysml/metamodel/ConnectionUsage.java | 5 +- app/org/omg/sysml/metamodel/Connector.java | 5 +- .../omg/sysml/metamodel/ConnectorAsUsage.java | 5 +- .../sysml/metamodel/ConstraintDefinition.java | 5 +- .../omg/sysml/metamodel/ConstraintUsage.java | 5 +- app/org/omg/sysml/metamodel/ControlNode.java | 5 +- app/org/omg/sysml/metamodel/DataType.java | 5 +- app/org/omg/sysml/metamodel/DecisionNode.java | 5 +- app/org/omg/sysml/metamodel/Definition.java | 5 +- app/org/omg/sysml/metamodel/Dependency.java | 5 +- app/org/omg/sysml/metamodel/Disjoining.java | 5 +- .../omg/sysml/metamodel/Documentation.java | 5 +- app/org/omg/sysml/metamodel/Element.java | 19 +- .../metamodel/ElementFilterMembership.java | 7 +- .../sysml/metamodel/EndFeatureMembership.java | 5 +- .../metamodel/EnumerationDefinition.java | 5 +- .../omg/sysml/metamodel/EnumerationUsage.java | 5 +- .../sysml/metamodel/EventOccurrenceUsage.java | 5 +- .../sysml/metamodel/ExhibitStateUsage.java | 5 +- app/org/omg/sysml/metamodel/Expose.java | 5 +- app/org/omg/sysml/metamodel/Expression.java | 5 +- app/org/omg/sysml/metamodel/Feature.java | 5 +- .../metamodel/FeatureChainExpression.java | 5 +- .../omg/sysml/metamodel/FeatureChaining.java | 5 +- .../sysml/metamodel/FeatureDirectionKind.java | 5 +- .../sysml/metamodel/FeatureMembership.java | 9 +- .../metamodel/FeatureReferenceExpression.java | 5 +- .../omg/sysml/metamodel/FeatureTyping.java | 5 +- app/org/omg/sysml/metamodel/FeatureValue.java | 7 +- .../sysml/metamodel/FlowConnectionUsage.java | 5 +- .../sysml/metamodel/ForLoopActionUsage.java | 5 +- app/org/omg/sysml/metamodel/ForkNode.java | 5 +- .../metamodel/FramedConcernMembership.java | 5 +- app/org/omg/sysml/metamodel/Function.java | 5 +- .../omg/sysml/metamodel/IfActionUsage.java | 5 +- app/org/omg/sysml/metamodel/Import.java | 5 +- .../sysml/metamodel/IncludeUseCaseUsage.java | 5 +- app/org/omg/sysml/metamodel/Interaction.java | 5 +- .../sysml/metamodel/InterfaceDefinition.java | 5 +- .../omg/sysml/metamodel/InterfaceUsage.java | 5 +- app/org/omg/sysml/metamodel/Invariant.java | 5 +- .../sysml/metamodel/InvocationExpression.java | 5 +- .../omg/sysml/metamodel/ItemDefinition.java | 5 +- app/org/omg/sysml/metamodel/ItemFeature.java | 5 +- app/org/omg/sysml/metamodel/ItemFlow.java | 5 +- app/org/omg/sysml/metamodel/ItemFlowEnd.java | 5 +- .../omg/sysml/metamodel/ItemFlowFeature.java | 5 +- app/org/omg/sysml/metamodel/ItemUsage.java | 5 +- app/org/omg/sysml/metamodel/JoinNode.java | 5 +- app/org/omg/sysml/metamodel/LifeClass.java | 5 +- .../omg/sysml/metamodel/LiteralBoolean.java | 5 +- .../sysml/metamodel/LiteralExpression.java | 5 +- .../omg/sysml/metamodel/LiteralInfinity.java | 5 +- .../omg/sysml/metamodel/LiteralInteger.java | 5 +- .../omg/sysml/metamodel/LiteralRational.java | 5 +- .../omg/sysml/metamodel/LiteralString.java | 5 +- .../omg/sysml/metamodel/LoopActionUsage.java | 5 +- app/org/omg/sysml/metamodel/Membership.java | 15 +- app/org/omg/sysml/metamodel/MergeNode.java | 5 +- app/org/omg/sysml/metamodel/Metaclass.java | 5 +- .../sysml/metamodel/MetadataDefinition.java | 7 +- .../omg/sysml/metamodel/MetadataFeature.java | 5 +- .../omg/sysml/metamodel/MetadataUsage.java | 7 +- app/org/omg/sysml/metamodel/Multiplicity.java | 5 +- .../sysml/metamodel/MultiplicityRange.java | 5 +- app/org/omg/sysml/metamodel/Namespace.java | 5 +- .../omg/sysml/metamodel/NullExpression.java | 5 +- .../sysml/metamodel/ObjectiveMembership.java | 5 +- .../sysml/metamodel/OccurrenceDefinition.java | 5 +- .../omg/sysml/metamodel/OccurrenceUsage.java | 5 +- .../sysml/metamodel/OperatorExpression.java | 5 +- .../omg/sysml/metamodel/OwningMembership.java | 37 + app/org/omg/sysml/metamodel/Package.java | 5 +- .../sysml/metamodel/ParameterMembership.java | 7 +- .../omg/sysml/metamodel/PartDefinition.java | 5 +- app/org/omg/sysml/metamodel/PartUsage.java | 5 +- .../sysml/metamodel/PerformActionUsage.java | 5 +- .../omg/sysml/metamodel/PortConjugation.java | 5 +- .../omg/sysml/metamodel/PortDefinition.java | 5 +- app/org/omg/sysml/metamodel/PortUsage.java | 7 +- app/org/omg/sysml/metamodel/PortionKind.java | 5 +- .../sysml/metamodel/PortioningFeature.java | 5 +- app/org/omg/sysml/metamodel/Predicate.java | 5 +- app/org/omg/sysml/metamodel/Redefinition.java | 5 +- .../omg/sysml/metamodel/ReferenceUsage.java | 5 +- app/org/omg/sysml/metamodel/Relationship.java | 5 +- .../sysml/metamodel/RenderingDefinition.java | 5 +- .../omg/sysml/metamodel/RenderingUsage.java | 5 +- .../metamodel/RequirementConstraintKind.java | 5 +- .../RequirementConstraintMembership.java | 5 +- .../metamodel/RequirementDefinition.java | 5 +- .../omg/sysml/metamodel/RequirementUsage.java | 5 +- .../RequirementVerificationMembership.java | 5 +- .../metamodel/ResultExpressionMembership.java | 5 +- .../metamodel/ReturnParameterMembership.java | 5 +- .../metamodel/SatisfyRequirementUsage.java | 5 +- .../omg/sysml/metamodel/SelectExpression.java | 5 +- .../omg/sysml/metamodel/SendActionUsage.java | 5 +- app/org/omg/sysml/metamodel/SourceEnd.java | 5 +- .../omg/sysml/metamodel/Specialization.java | 5 +- .../metamodel/StakeholderMembership.java | 5 +- .../omg/sysml/metamodel/StateDefinition.java | 5 +- .../sysml/metamodel/StateSubactionKind.java | 5 +- .../metamodel/StateSubactionMembership.java | 5 +- app/org/omg/sysml/metamodel/StateUsage.java | 5 +- app/org/omg/sysml/metamodel/Step.java | 5 +- app/org/omg/sysml/metamodel/Structure.java | 5 +- .../sysml/metamodel/Subclassification.java | 5 +- .../sysml/metamodel/SubjectMembership.java | 5 +- app/org/omg/sysml/metamodel/Subsetting.java | 5 +- app/org/omg/sysml/metamodel/Succession.java | 5 +- .../sysml/metamodel/SuccessionAsUsage.java | 5 +- .../SuccessionFlowConnectionUsage.java | 5 +- .../sysml/metamodel/SuccessionItemFlow.java | 5 +- app/org/omg/sysml/metamodel/TargetEnd.java | 5 +- .../metamodel/TextualRepresentation.java | 5 +- .../metamodel/TransitionFeatureKind.java | 5 +- .../TransitionFeatureMembership.java | 5 +- .../omg/sysml/metamodel/TransitionUsage.java | 5 +- .../TriggerInvocationExpression.java | 5 +- app/org/omg/sysml/metamodel/TriggerKind.java | 5 +- app/org/omg/sysml/metamodel/Type.java | 9 +- .../omg/sysml/metamodel/TypeFeaturing.java | 5 +- app/org/omg/sysml/metamodel/Usage.java | 5 +- .../sysml/metamodel/UseCaseDefinition.java | 5 +- app/org/omg/sysml/metamodel/UseCaseUsage.java | 5 +- .../sysml/metamodel/VariantMembership.java | 7 +- .../metamodel/VerificationCaseDefinition.java | 5 +- .../metamodel/VerificationCaseUsage.java | 5 +- .../omg/sysml/metamodel/ViewDefinition.java | 5 +- .../metamodel/ViewRenderingMembership.java | 5 +- app/org/omg/sysml/metamodel/ViewUsage.java | 5 +- .../sysml/metamodel/ViewpointDefinition.java | 5 +- .../omg/sysml/metamodel/ViewpointUsage.java | 5 +- .../omg/sysml/metamodel/VisibilityKind.java | 5 +- .../sysml/metamodel/WhileLoopActionUsage.java | 5 +- .../metamodel/impl/AcceptActionUsageImpl.java | 569 +++++++------- .../metamodel/impl/ActionDefinitionImpl.java | 479 ++++++------ .../sysml/metamodel/impl/ActionUsageImpl.java | 557 +++++++------- .../metamodel/impl/ActorMembershipImpl.java | 333 +++++---- .../impl/AllocationDefinitionImpl.java | 523 +++++++------ .../metamodel/impl/AllocationUsageImpl.java | 619 ++++++++------- .../impl/AnalysisCaseDefinitionImpl.java | 519 +++++++------ .../metamodel/impl/AnalysisCaseUsageImpl.java | 601 ++++++++------- .../metamodel/impl/AnnotatingElementImpl.java | 143 ++-- .../sysml/metamodel/impl/AnnotationImpl.java | 171 +++-- .../impl/AssertConstraintUsageImpl.java | 571 +++++++------- .../impl/AssignmentActionUsageImpl.java | 569 +++++++------- .../sysml/metamodel/impl/AssociationImpl.java | 327 ++++---- .../impl/AssociationStructureImpl.java | 327 ++++---- .../impl/AttributeDefinitionImpl.java | 457 ++++++------ .../metamodel/impl/AttributeUsageImpl.java | 531 +++++++------ .../sysml/metamodel/impl/BehaviorImpl.java | 289 ++++--- .../impl/BindingConnectorAsUsageImpl.java | 581 +++++++------- .../metamodel/impl/BindingConnectorImpl.java | 387 +++++----- .../metamodel/impl/BooleanExpressionImpl.java | 355 +++++---- .../impl/CalculationDefinitionImpl.java | 495 ++++++------ .../metamodel/impl/CalculationUsageImpl.java | 569 +++++++------- .../metamodel/impl/CaseDefinitionImpl.java | 509 +++++++------ .../sysml/metamodel/impl/CaseUsageImpl.java | 587 ++++++++------- .../omg/sysml/metamodel/impl/ClassImpl.java | 277 ++++--- .../sysml/metamodel/impl/ClassifierImpl.java | 277 ++++--- .../metamodel/impl/CollectExpressionImpl.java | 363 +++++---- .../omg/sysml/metamodel/impl/CommentImpl.java | 143 ++-- .../metamodel/impl/ConcernDefinitionImpl.java | 519 +++++++------ .../metamodel/impl/ConcernUsageImpl.java | 611 ++++++++------- .../impl/ConjugatedPortDefinitionImpl.java | 473 ++++++------ .../impl/ConjugatedPortTypingImpl.java | 207 +++-- .../sysml/metamodel/impl/ConjugationImpl.java | 171 +++-- .../impl/ConnectionDefinitionImpl.java | 517 +++++++------ .../metamodel/impl/ConnectionUsageImpl.java | 613 ++++++++------- .../metamodel/impl/ConnectorAsUsageImpl.java | 581 +++++++------- .../sysml/metamodel/impl/ConnectorImpl.java | 387 +++++----- .../impl/ConstraintDefinitionImpl.java | 483 ++++++------ .../metamodel/impl/ConstraintUsageImpl.java | 567 +++++++------- .../sysml/metamodel/impl/ControlNodeImpl.java | 557 +++++++------- .../sysml/metamodel/impl/DataTypeImpl.java | 277 ++++--- .../metamodel/impl/DecisionNodeImpl.java | 557 +++++++------- .../sysml/metamodel/impl/DefinitionImpl.java | 457 ++++++------ .../sysml/metamodel/impl/DependencyImpl.java | 171 +++-- .../sysml/metamodel/impl/DisjoiningImpl.java | 171 +++-- .../metamodel/impl/DocumentationImpl.java | 147 ++-- .../impl/ElementFilterMembershipImpl.java | 291 +++++--- .../omg/sysml/metamodel/impl/ElementImpl.java | 131 ++-- .../impl/EndFeatureMembershipImpl.java | 324 ++++---- .../impl/EnumerationDefinitionImpl.java | 463 ++++++------ .../metamodel/impl/EnumerationUsageImpl.java | 535 +++++++------ .../impl/EventOccurrenceUsageImpl.java | 543 +++++++------- .../metamodel/impl/ExhibitStateUsageImpl.java | 587 ++++++++------- .../omg/sysml/metamodel/impl/ExposeImpl.java | 167 ++--- .../sysml/metamodel/impl/ExpressionImpl.java | 351 +++++---- .../impl/FeatureChainExpressionImpl.java | 367 +++++---- .../metamodel/impl/FeatureChainingImpl.java | 185 +++-- .../omg/sysml/metamodel/impl/FeatureImpl.java | 331 ++++---- .../metamodel/impl/FeatureMembershipImpl.java | 324 ++++---- .../impl/FeatureReferenceExpressionImpl.java | 355 +++++---- .../metamodel/impl/FeatureTypingImpl.java | 199 +++-- .../metamodel/impl/FeatureValueImpl.java | 311 +++++--- .../impl/FlowConnectionUsageImpl.java | 661 ++++++++-------- .../impl/ForLoopActionUsageImpl.java | 569 +++++++------- .../sysml/metamodel/impl/ForkNodeImpl.java | 557 +++++++------- .../impl/FramedConcernMembershipImpl.java | 340 +++++---- .../sysml/metamodel/impl/FunctionImpl.java | 299 ++++---- .../metamodel/impl/IfActionUsageImpl.java | 569 +++++++------- .../omg/sysml/metamodel/impl/ImportImpl.java | 167 ++--- .../impl/IncludeUseCaseUsageImpl.java | 609 ++++++++------- .../sysml/metamodel/impl/InteractionImpl.java | 339 +++++---- .../impl/InterfaceDefinitionImpl.java | 523 +++++++------ .../metamodel/impl/InterfaceUsageImpl.java | 619 ++++++++------- .../sysml/metamodel/impl/InvariantImpl.java | 355 +++++---- .../impl/InvocationExpressionImpl.java | 357 +++++---- .../metamodel/impl/ItemDefinitionImpl.java | 461 ++++++------ .../sysml/metamodel/impl/ItemFeatureImpl.java | 331 ++++---- .../sysml/metamodel/impl/ItemFlowEndImpl.java | 331 ++++---- .../metamodel/impl/ItemFlowFeatureImpl.java | 331 ++++---- .../sysml/metamodel/impl/ItemFlowImpl.java | 435 ++++++----- .../sysml/metamodel/impl/ItemUsageImpl.java | 545 +++++++------- .../sysml/metamodel/impl/JoinNodeImpl.java | 557 +++++++------- .../sysml/metamodel/impl/LifeClassImpl.java | 277 ++++--- .../metamodel/impl/LiteralBooleanImpl.java | 351 +++++---- .../metamodel/impl/LiteralExpressionImpl.java | 351 +++++---- .../metamodel/impl/LiteralInfinityImpl.java | 351 +++++---- .../metamodel/impl/LiteralIntegerImpl.java | 351 +++++---- .../metamodel/impl/LiteralRationalImpl.java | 351 +++++---- .../metamodel/impl/LiteralStringImpl.java | 351 +++++---- .../metamodel/impl/LoopActionUsageImpl.java | 561 +++++++------- .../sysml/metamodel/impl/MembershipImpl.java | 242 +++--- .../sysml/metamodel/impl/MergeNodeImpl.java | 557 +++++++------- .../sysml/metamodel/impl/MetaclassImpl.java | 277 ++++--- .../impl/MetadataDefinitionImpl.java | 461 ++++++------ .../metamodel/impl/MetadataFeatureImpl.java | 347 +++++---- .../metamodel/impl/MetadataUsageImpl.java | 565 +++++++------- .../metamodel/impl/MultiplicityImpl.java | 331 ++++---- .../metamodel/impl/MultiplicityRangeImpl.java | 345 +++++---- .../sysml/metamodel/impl/NamespaceImpl.java | 167 ++--- .../metamodel/impl/NullExpressionImpl.java | 351 +++++---- .../impl/ObjectiveMembershipImpl.java | 328 ++++---- .../impl/OccurrenceDefinitionImpl.java | 461 ++++++------ .../metamodel/impl/OccurrenceUsageImpl.java | 539 +++++++------ .../impl/OperatorExpressionImpl.java | 363 +++++---- .../metamodel/impl/OwningMembershipImpl.java | 706 ++++++++++++++++++ .../omg/sysml/metamodel/impl/PackageImpl.java | 191 +++-- .../impl/ParameterMembershipImpl.java | 329 ++++---- .../metamodel/impl/PartDefinitionImpl.java | 461 ++++++------ .../sysml/metamodel/impl/PartUsageImpl.java | 551 +++++++------- .../impl/PerformActionUsageImpl.java | 565 +++++++------- .../metamodel/impl/PortConjugationImpl.java | 179 +++-- .../metamodel/impl/PortDefinitionImpl.java | 465 ++++++------ .../sysml/metamodel/impl/PortUsageImpl.java | 566 +++++++------- .../metamodel/impl/PortioningFeatureImpl.java | 331 ++++---- .../sysml/metamodel/impl/PredicateImpl.java | 299 ++++---- .../metamodel/impl/RedefinitionImpl.java | 207 +++-- .../metamodel/impl/ReferenceUsageImpl.java | 525 +++++++------ .../metamodel/impl/RelationshipImpl.java | 159 ++-- .../impl/RenderingDefinitionImpl.java | 467 ++++++------ .../metamodel/impl/RenderingUsageImpl.java | 555 +++++++------- .../RequirementConstraintMembershipImpl.java | 332 ++++---- .../impl/RequirementDefinitionImpl.java | 519 +++++++------ .../metamodel/impl/RequirementUsageImpl.java | 607 ++++++++------- ...RequirementVerificationMembershipImpl.java | 340 +++++---- .../impl/ResultExpressionMembershipImpl.java | 328 ++++---- .../impl/ReturnParameterMembershipImpl.java | 329 ++++---- .../impl/SatisfyRequirementUsageImpl.java | 619 ++++++++------- .../metamodel/impl/SelectExpressionImpl.java | 363 +++++---- .../metamodel/impl/SendActionUsageImpl.java | 565 +++++++------- .../sysml/metamodel/impl/SourceEndImpl.java | 331 ++++---- .../metamodel/impl/SpecializationImpl.java | 187 +++-- .../impl/StakeholderMembershipImpl.java | 333 +++++---- .../metamodel/impl/StateDefinitionImpl.java | 497 ++++++------ .../impl/StateSubactionMembershipImpl.java | 328 ++++---- .../sysml/metamodel/impl/StateUsageImpl.java | 575 +++++++------- .../omg/sysml/metamodel/impl/StepImpl.java | 343 +++++---- .../sysml/metamodel/impl/StructureImpl.java | 277 ++++--- .../metamodel/impl/SubclassificationImpl.java | 199 +++-- .../metamodel/impl/SubjectMembershipImpl.java | 333 +++++---- .../sysml/metamodel/impl/SubsettingImpl.java | 199 +++-- .../metamodel/impl/SuccessionAsUsageImpl.java | 603 ++++++++------- .../SuccessionFlowConnectionUsageImpl.java | 683 +++++++++-------- .../sysml/metamodel/impl/SuccessionImpl.java | 409 +++++----- .../impl/SuccessionItemFlowImpl.java | 457 ++++++------ .../sysml/metamodel/impl/SysMLTypeImpl.java | 8 +- .../sysml/metamodel/impl/TargetEndImpl.java | 331 ++++---- .../impl/TextualRepresentationImpl.java | 147 ++-- .../impl/TransitionFeatureMembershipImpl.java | 328 ++++---- .../metamodel/impl/TransitionUsageImpl.java | 587 ++++++++------- .../impl/TriggerInvocationExpressionImpl.java | 357 +++++---- .../metamodel/impl/TypeFeaturingImpl.java | 189 +++-- .../omg/sysml/metamodel/impl/TypeImpl.java | 271 ++++--- .../omg/sysml/metamodel/impl/UsageImpl.java | 525 +++++++------ .../metamodel/impl/UseCaseDefinitionImpl.java | 515 +++++++------ .../metamodel/impl/UseCaseUsageImpl.java | 597 ++++++++------- .../metamodel/impl/VariantMembershipImpl.java | 291 +++++--- .../impl/VerificationCaseDefinitionImpl.java | 515 +++++++------ .../impl/VerificationCaseUsageImpl.java | 597 ++++++++------- .../metamodel/impl/ViewDefinitionImpl.java | 483 ++++++------ .../impl/ViewRenderingMembershipImpl.java | 332 ++++---- .../sysml/metamodel/impl/ViewUsageImpl.java | 583 ++++++++------- .../impl/ViewpointDefinitionImpl.java | 525 +++++++------ .../metamodel/impl/ViewpointUsageImpl.java | 617 ++++++++------- .../impl/WhileLoopActionUsageImpl.java | 569 +++++++------- .../sysml/metamodel/impl/package-info.java | 26 + app/services/ElementService.java | 2 +- app/services/RelationshipService.java | 2 +- conf/META-INF/persistence.xml | 1 + .../impl/AcceptActionUsageImpl_.java | 12 +- .../metamodel/impl/ActionDefinitionImpl_.java | 12 +- .../metamodel/impl/ActionUsageImpl_.java | 12 +- .../metamodel/impl/ActorMembershipImpl_.java | 24 +- .../impl/AllocationDefinitionImpl_.java | 12 +- .../metamodel/impl/AllocationUsageImpl_.java | 12 +- .../impl/AnalysisCaseDefinitionImpl_.java | 12 +- .../impl/AnalysisCaseUsageImpl_.java | 12 +- .../impl/AnnotatingElementImpl_.java | 12 +- .../sysml/metamodel/impl/AnnotationImpl_.java | 12 +- .../impl/AssertConstraintUsageImpl_.java | 12 +- .../impl/AssignmentActionUsageImpl_.java | 12 +- .../metamodel/impl/AssociationImpl_.java | 12 +- .../impl/AssociationStructureImpl_.java | 12 +- .../impl/AttributeDefinitionImpl_.java | 12 +- .../metamodel/impl/AttributeUsageImpl_.java | 12 +- .../sysml/metamodel/impl/BehaviorImpl_.java | 12 +- .../impl/BindingConnectorAsUsageImpl_.java | 12 +- .../metamodel/impl/BindingConnectorImpl_.java | 12 +- .../impl/BooleanExpressionImpl_.java | 12 +- .../impl/CalculationDefinitionImpl_.java | 12 +- .../metamodel/impl/CalculationUsageImpl_.java | 12 +- .../metamodel/impl/CaseDefinitionImpl_.java | 12 +- .../sysml/metamodel/impl/CaseUsageImpl_.java | 12 +- .../omg/sysml/metamodel/impl/ClassImpl_.java | 12 +- .../sysml/metamodel/impl/ClassifierImpl_.java | 12 +- .../impl/CollectExpressionImpl_.java | 12 +- .../sysml/metamodel/impl/CommentImpl_.java | 12 +- .../impl/ConcernDefinitionImpl_.java | 12 +- .../metamodel/impl/ConcernUsageImpl_.java | 12 +- .../impl/ConjugatedPortDefinitionImpl_.java | 12 +- .../impl/ConjugatedPortTypingImpl_.java | 12 +- .../metamodel/impl/ConjugationImpl_.java | 12 +- .../impl/ConnectionDefinitionImpl_.java | 12 +- .../metamodel/impl/ConnectionUsageImpl_.java | 12 +- .../metamodel/impl/ConnectorAsUsageImpl_.java | 12 +- .../sysml/metamodel/impl/ConnectorImpl_.java | 12 +- .../impl/ConstraintDefinitionImpl_.java | 12 +- .../metamodel/impl/ConstraintUsageImpl_.java | 12 +- .../metamodel/impl/ControlNodeImpl_.java | 12 +- .../sysml/metamodel/impl/DataTypeImpl_.java | 12 +- .../metamodel/impl/DecisionNodeImpl_.java | 12 +- .../sysml/metamodel/impl/DefinitionImpl_.java | 12 +- .../sysml/metamodel/impl/DependencyImpl_.java | 12 +- .../sysml/metamodel/impl/DisjoiningImpl_.java | 12 +- .../metamodel/impl/DocumentationImpl_.java | 12 +- .../impl/ElementFilterMembershipImpl_.java | 24 +- .../sysml/metamodel/impl/ElementImpl_.java | 12 +- .../impl/EndFeatureMembershipImpl_.java | 24 +- .../impl/EnumerationDefinitionImpl_.java | 12 +- .../metamodel/impl/EnumerationUsageImpl_.java | 12 +- .../impl/EventOccurrenceUsageImpl_.java | 12 +- .../impl/ExhibitStateUsageImpl_.java | 12 +- .../omg/sysml/metamodel/impl/ExposeImpl_.java | 12 +- .../sysml/metamodel/impl/ExpressionImpl_.java | 12 +- .../impl/FeatureChainExpressionImpl_.java | 12 +- .../metamodel/impl/FeatureChainingImpl_.java | 12 +- .../sysml/metamodel/impl/FeatureImpl_.java | 12 +- .../impl/FeatureMembershipImpl_.java | 24 +- .../impl/FeatureReferenceExpressionImpl_.java | 12 +- .../metamodel/impl/FeatureTypingImpl_.java | 12 +- .../metamodel/impl/FeatureValueImpl_.java | 24 +- .../impl/FlowConnectionUsageImpl_.java | 12 +- .../impl/ForLoopActionUsageImpl_.java | 12 +- .../sysml/metamodel/impl/ForkNodeImpl_.java | 12 +- .../impl/FramedConcernMembershipImpl_.java | 24 +- .../sysml/metamodel/impl/FunctionImpl_.java | 12 +- .../metamodel/impl/IfActionUsageImpl_.java | 12 +- .../omg/sysml/metamodel/impl/ImportImpl_.java | 12 +- .../impl/IncludeUseCaseUsageImpl_.java | 12 +- .../metamodel/impl/InteractionImpl_.java | 12 +- .../impl/InterfaceDefinitionImpl_.java | 12 +- .../metamodel/impl/InterfaceUsageImpl_.java | 12 +- .../sysml/metamodel/impl/InvariantImpl_.java | 12 +- .../impl/InvocationExpressionImpl_.java | 12 +- .../metamodel/impl/ItemDefinitionImpl_.java | 12 +- .../metamodel/impl/ItemFeatureImpl_.java | 12 +- .../metamodel/impl/ItemFlowEndImpl_.java | 12 +- .../metamodel/impl/ItemFlowFeatureImpl_.java | 12 +- .../sysml/metamodel/impl/ItemFlowImpl_.java | 12 +- .../sysml/metamodel/impl/ItemUsageImpl_.java | 12 +- .../sysml/metamodel/impl/JoinNodeImpl_.java | 12 +- .../sysml/metamodel/impl/LifeClassImpl_.java | 12 +- .../metamodel/impl/LiteralBooleanImpl_.java | 12 +- .../impl/LiteralExpressionImpl_.java | 12 +- .../metamodel/impl/LiteralInfinityImpl_.java | 12 +- .../metamodel/impl/LiteralIntegerImpl_.java | 12 +- .../metamodel/impl/LiteralRationalImpl_.java | 12 +- .../metamodel/impl/LiteralStringImpl_.java | 12 +- .../metamodel/impl/LoopActionUsageImpl_.java | 12 +- .../sysml/metamodel/impl/MembershipImpl_.java | 18 +- .../sysml/metamodel/impl/MergeNodeImpl_.java | 12 +- .../sysml/metamodel/impl/MetaclassImpl_.java | 12 +- .../impl/MetadataDefinitionImpl_.java | 12 +- .../metamodel/impl/MetadataFeatureImpl_.java | 12 +- .../metamodel/impl/MetadataUsageImpl_.java | 12 +- .../metamodel/impl/MultiplicityImpl_.java | 12 +- .../impl/MultiplicityRangeImpl_.java | 12 +- .../sysml/metamodel/impl/NamespaceImpl_.java | 12 +- .../metamodel/impl/NullExpressionImpl_.java | 12 +- .../impl/ObjectiveMembershipImpl_.java | 24 +- .../impl/OccurrenceDefinitionImpl_.java | 12 +- .../metamodel/impl/OccurrenceUsageImpl_.java | 12 +- .../impl/OperatorExpressionImpl_.java | 12 +- .../metamodel/impl/OwningMembershipImpl_.java | 66 ++ .../sysml/metamodel/impl/PackageImpl_.java | 12 +- .../impl/ParameterMembershipImpl_.java | 24 +- .../metamodel/impl/PartDefinitionImpl_.java | 12 +- .../sysml/metamodel/impl/PartUsageImpl_.java | 12 +- .../impl/PerformActionUsageImpl_.java | 12 +- .../metamodel/impl/PortConjugationImpl_.java | 12 +- .../metamodel/impl/PortDefinitionImpl_.java | 12 +- .../sysml/metamodel/impl/PortUsageImpl_.java | 12 +- .../impl/PortioningFeatureImpl_.java | 12 +- .../sysml/metamodel/impl/PredicateImpl_.java | 12 +- .../metamodel/impl/RedefinitionImpl_.java | 12 +- .../metamodel/impl/ReferenceUsageImpl_.java | 12 +- .../metamodel/impl/RelationshipImpl_.java | 12 +- .../impl/RenderingDefinitionImpl_.java | 12 +- .../metamodel/impl/RenderingUsageImpl_.java | 12 +- .../RequirementConstraintMembershipImpl_.java | 24 +- .../impl/RequirementDefinitionImpl_.java | 12 +- .../metamodel/impl/RequirementUsageImpl_.java | 12 +- ...equirementVerificationMembershipImpl_.java | 24 +- .../impl/ResultExpressionMembershipImpl_.java | 24 +- .../impl/ReturnParameterMembershipImpl_.java | 24 +- .../impl/SatisfyRequirementUsageImpl_.java | 12 +- .../metamodel/impl/SelectExpressionImpl_.java | 12 +- .../metamodel/impl/SendActionUsageImpl_.java | 12 +- .../sysml/metamodel/impl/SourceEndImpl_.java | 12 +- .../metamodel/impl/SpecializationImpl_.java | 12 +- .../impl/StakeholderMembershipImpl_.java | 24 +- .../metamodel/impl/StateDefinitionImpl_.java | 12 +- .../impl/StateSubactionMembershipImpl_.java | 24 +- .../sysml/metamodel/impl/StateUsageImpl_.java | 12 +- .../omg/sysml/metamodel/impl/StepImpl_.java | 12 +- .../sysml/metamodel/impl/StructureImpl_.java | 12 +- .../impl/SubclassificationImpl_.java | 12 +- .../impl/SubjectMembershipImpl_.java | 24 +- .../sysml/metamodel/impl/SubsettingImpl_.java | 12 +- .../impl/SuccessionAsUsageImpl_.java | 12 +- .../SuccessionFlowConnectionUsageImpl_.java | 12 +- .../sysml/metamodel/impl/SuccessionImpl_.java | 12 +- .../impl/SuccessionItemFlowImpl_.java | 12 +- .../sysml/metamodel/impl/TargetEndImpl_.java | 12 +- .../impl/TextualRepresentationImpl_.java | 12 +- .../TransitionFeatureMembershipImpl_.java | 24 +- .../metamodel/impl/TransitionUsageImpl_.java | 12 +- .../TriggerInvocationExpressionImpl_.java | 12 +- .../metamodel/impl/TypeFeaturingImpl_.java | 12 +- .../omg/sysml/metamodel/impl/TypeImpl_.java | 12 +- .../omg/sysml/metamodel/impl/UsageImpl_.java | 12 +- .../impl/UseCaseDefinitionImpl_.java | 12 +- .../metamodel/impl/UseCaseUsageImpl_.java | 12 +- .../impl/VariantMembershipImpl_.java | 24 +- .../impl/VerificationCaseDefinitionImpl_.java | 12 +- .../impl/VerificationCaseUsageImpl_.java | 12 +- .../metamodel/impl/ViewDefinitionImpl_.java | 12 +- .../impl/ViewRenderingMembershipImpl_.java | 24 +- .../sysml/metamodel/impl/ViewUsageImpl_.java | 12 +- .../impl/ViewpointDefinitionImpl_.java | 12 +- .../metamodel/impl/ViewpointUsageImpl_.java | 12 +- .../impl/WhileLoopActionUsageImpl_.java | 12 +- .../jsonld/metamodel/AcceptActionUsage.jsonld | 6 +- .../jsonld/metamodel/ActionDefinition.jsonld | 6 +- public/jsonld/metamodel/ActionUsage.jsonld | 6 +- .../jsonld/metamodel/ActorMembership.jsonld | 14 +- .../metamodel/AllocationDefinition.jsonld | 6 +- .../jsonld/metamodel/AllocationUsage.jsonld | 6 +- .../metamodel/AnalysisCaseDefinition.jsonld | 6 +- .../jsonld/metamodel/AnalysisCaseUsage.jsonld | 6 +- .../jsonld/metamodel/AnnotatingElement.jsonld | 6 +- public/jsonld/metamodel/Annotation.jsonld | 6 +- .../metamodel/AssertConstraintUsage.jsonld | 6 +- .../metamodel/AssignmentActionUsage.jsonld | 6 +- public/jsonld/metamodel/Association.jsonld | 6 +- .../metamodel/AssociationStructure.jsonld | 6 +- .../metamodel/AttributeDefinition.jsonld | 6 +- public/jsonld/metamodel/AttributeUsage.jsonld | 6 +- public/jsonld/metamodel/Behavior.jsonld | 6 +- .../jsonld/metamodel/BindingConnector.jsonld | 6 +- .../metamodel/BindingConnectorAsUsage.jsonld | 6 +- .../jsonld/metamodel/BooleanExpression.jsonld | 6 +- .../metamodel/CalculationDefinition.jsonld | 6 +- .../jsonld/metamodel/CalculationUsage.jsonld | 6 +- public/jsonld/metamodel/CaseDefinition.jsonld | 6 +- public/jsonld/metamodel/CaseUsage.jsonld | 6 +- public/jsonld/metamodel/Class.jsonld | 6 +- public/jsonld/metamodel/Classifier.jsonld | 6 +- .../jsonld/metamodel/CollectExpression.jsonld | 6 +- public/jsonld/metamodel/Comment.jsonld | 6 +- .../jsonld/metamodel/ConcernDefinition.jsonld | 6 +- public/jsonld/metamodel/ConcernUsage.jsonld | 6 +- .../metamodel/ConjugatedPortDefinition.jsonld | 6 +- .../metamodel/ConjugatedPortTyping.jsonld | 6 +- public/jsonld/metamodel/Conjugation.jsonld | 6 +- .../metamodel/ConnectionDefinition.jsonld | 6 +- .../jsonld/metamodel/ConnectionUsage.jsonld | 6 +- public/jsonld/metamodel/Connector.jsonld | 6 +- .../jsonld/metamodel/ConnectorAsUsage.jsonld | 6 +- .../metamodel/ConstraintDefinition.jsonld | 6 +- .../jsonld/metamodel/ConstraintUsage.jsonld | 6 +- public/jsonld/metamodel/ControlNode.jsonld | 6 +- public/jsonld/metamodel/DataType.jsonld | 6 +- public/jsonld/metamodel/DecisionNode.jsonld | 6 +- public/jsonld/metamodel/Definition.jsonld | 6 +- public/jsonld/metamodel/Dependency.jsonld | 6 +- public/jsonld/metamodel/Disjoining.jsonld | 6 +- public/jsonld/metamodel/Documentation.jsonld | 6 +- public/jsonld/metamodel/Element.jsonld | 6 +- .../metamodel/ElementFilterMembership.jsonld | 12 +- .../metamodel/EndFeatureMembership.jsonld | 13 +- .../metamodel/EnumerationDefinition.jsonld | 6 +- .../jsonld/metamodel/EnumerationUsage.jsonld | 6 +- .../metamodel/EventOccurrenceUsage.jsonld | 6 +- .../jsonld/metamodel/ExhibitStateUsage.jsonld | 6 +- public/jsonld/metamodel/Expose.jsonld | 6 +- public/jsonld/metamodel/Expression.jsonld | 6 +- public/jsonld/metamodel/Feature.jsonld | 6 +- .../metamodel/FeatureChainExpression.jsonld | 6 +- .../jsonld/metamodel/FeatureChaining.jsonld | 6 +- .../jsonld/metamodel/FeatureMembership.jsonld | 13 +- .../FeatureReferenceExpression.jsonld | 6 +- public/jsonld/metamodel/FeatureTyping.jsonld | 6 +- public/jsonld/metamodel/FeatureValue.jsonld | 12 +- .../metamodel/FlowConnectionUsage.jsonld | 6 +- .../metamodel/ForLoopActionUsage.jsonld | 6 +- public/jsonld/metamodel/ForkNode.jsonld | 6 +- .../metamodel/FramedConcernMembership.jsonld | 13 +- public/jsonld/metamodel/Function.jsonld | 6 +- public/jsonld/metamodel/IfActionUsage.jsonld | 6 +- public/jsonld/metamodel/Import.jsonld | 6 +- .../metamodel/IncludeUseCaseUsage.jsonld | 6 +- public/jsonld/metamodel/Interaction.jsonld | 6 +- .../metamodel/InterfaceDefinition.jsonld | 6 +- public/jsonld/metamodel/InterfaceUsage.jsonld | 6 +- public/jsonld/metamodel/Invariant.jsonld | 6 +- .../metamodel/InvocationExpression.jsonld | 6 +- public/jsonld/metamodel/ItemDefinition.jsonld | 6 +- public/jsonld/metamodel/ItemFeature.jsonld | 6 +- public/jsonld/metamodel/ItemFlow.jsonld | 6 +- public/jsonld/metamodel/ItemFlowEnd.jsonld | 6 +- .../jsonld/metamodel/ItemFlowFeature.jsonld | 6 +- public/jsonld/metamodel/ItemUsage.jsonld | 6 +- public/jsonld/metamodel/JoinNode.jsonld | 6 +- public/jsonld/metamodel/LifeClass.jsonld | 6 +- public/jsonld/metamodel/LiteralBoolean.jsonld | 6 +- .../jsonld/metamodel/LiteralExpression.jsonld | 6 +- .../jsonld/metamodel/LiteralInfinity.jsonld | 6 +- public/jsonld/metamodel/LiteralInteger.jsonld | 6 +- .../jsonld/metamodel/LiteralRational.jsonld | 6 +- public/jsonld/metamodel/LiteralString.jsonld | 6 +- .../jsonld/metamodel/LoopActionUsage.jsonld | 6 +- public/jsonld/metamodel/Membership.jsonld | 10 +- public/jsonld/metamodel/MergeNode.jsonld | 6 +- public/jsonld/metamodel/Metaclass.jsonld | 6 +- .../metamodel/MetadataDefinition.jsonld | 6 +- .../jsonld/metamodel/MetadataFeature.jsonld | 6 +- public/jsonld/metamodel/MetadataUsage.jsonld | 6 +- public/jsonld/metamodel/Multiplicity.jsonld | 6 +- .../jsonld/metamodel/MultiplicityRange.jsonld | 6 +- public/jsonld/metamodel/Namespace.jsonld | 6 +- public/jsonld/metamodel/NullExpression.jsonld | 6 +- .../metamodel/ObjectiveMembership.jsonld | 13 +- .../metamodel/OccurrenceDefinition.jsonld | 6 +- .../jsonld/metamodel/OccurrenceUsage.jsonld | 6 +- .../metamodel/OperatorExpression.jsonld | 6 +- .../jsonld/metamodel/OwningMembership.jsonld | 40 + public/jsonld/metamodel/Package.jsonld | 6 +- .../metamodel/ParameterMembership.jsonld | 14 +- public/jsonld/metamodel/PartDefinition.jsonld | 6 +- public/jsonld/metamodel/PartUsage.jsonld | 6 +- .../metamodel/PerformActionUsage.jsonld | 6 +- .../jsonld/metamodel/PortConjugation.jsonld | 6 +- public/jsonld/metamodel/PortDefinition.jsonld | 6 +- public/jsonld/metamodel/PortUsage.jsonld | 7 +- .../jsonld/metamodel/PortioningFeature.jsonld | 6 +- public/jsonld/metamodel/Predicate.jsonld | 6 +- public/jsonld/metamodel/Redefinition.jsonld | 6 +- public/jsonld/metamodel/ReferenceUsage.jsonld | 6 +- public/jsonld/metamodel/Relationship.jsonld | 6 +- .../metamodel/RenderingDefinition.jsonld | 6 +- public/jsonld/metamodel/RenderingUsage.jsonld | 6 +- .../RequirementConstraintMembership.jsonld | 13 +- .../metamodel/RequirementDefinition.jsonld | 6 +- .../jsonld/metamodel/RequirementUsage.jsonld | 6 +- .../RequirementVerificationMembership.jsonld | 13 +- .../ResultExpressionMembership.jsonld | 13 +- .../ReturnParameterMembership.jsonld | 14 +- .../metamodel/SatisfyRequirementUsage.jsonld | 6 +- .../jsonld/metamodel/SelectExpression.jsonld | 6 +- .../jsonld/metamodel/SendActionUsage.jsonld | 6 +- public/jsonld/metamodel/SourceEnd.jsonld | 6 +- public/jsonld/metamodel/Specialization.jsonld | 6 +- .../metamodel/StakeholderMembership.jsonld | 14 +- .../jsonld/metamodel/StateDefinition.jsonld | 6 +- .../metamodel/StateSubactionMembership.jsonld | 13 +- public/jsonld/metamodel/StateUsage.jsonld | 6 +- public/jsonld/metamodel/Step.jsonld | 6 +- public/jsonld/metamodel/Structure.jsonld | 6 +- .../jsonld/metamodel/Subclassification.jsonld | 6 +- .../jsonld/metamodel/SubjectMembership.jsonld | 14 +- public/jsonld/metamodel/Subsetting.jsonld | 6 +- public/jsonld/metamodel/Succession.jsonld | 6 +- .../jsonld/metamodel/SuccessionAsUsage.jsonld | 6 +- .../SuccessionFlowConnectionUsage.jsonld | 6 +- .../metamodel/SuccessionItemFlow.jsonld | 6 +- public/jsonld/metamodel/TargetEnd.jsonld | 6 +- .../metamodel/TextualRepresentation.jsonld | 6 +- .../TransitionFeatureMembership.jsonld | 13 +- .../jsonld/metamodel/TransitionUsage.jsonld | 6 +- .../TriggerInvocationExpression.jsonld | 6 +- public/jsonld/metamodel/Type.jsonld | 6 +- public/jsonld/metamodel/TypeFeaturing.jsonld | 6 +- public/jsonld/metamodel/Usage.jsonld | 6 +- .../jsonld/metamodel/UseCaseDefinition.jsonld | 6 +- public/jsonld/metamodel/UseCaseUsage.jsonld | 6 +- .../jsonld/metamodel/VariantMembership.jsonld | 12 +- .../VerificationCaseDefinition.jsonld | 6 +- .../metamodel/VerificationCaseUsage.jsonld | 6 +- public/jsonld/metamodel/ViewDefinition.jsonld | 6 +- .../metamodel/ViewRenderingMembership.jsonld | 13 +- public/jsonld/metamodel/ViewUsage.jsonld | 6 +- .../metamodel/ViewpointDefinition.jsonld | 6 +- public/jsonld/metamodel/ViewpointUsage.jsonld | 6 +- .../metamodel/WhileLoopActionUsage.jsonld | 6 +- 670 files changed, 36707 insertions(+), 34626 deletions(-) create mode 100644 app/org/omg/sysml/metamodel/OwningMembership.java create mode 100644 app/org/omg/sysml/metamodel/impl/OwningMembershipImpl.java create mode 100644 generated/org/omg/sysml/metamodel/impl/OwningMembershipImpl_.java create mode 100644 public/jsonld/metamodel/OwningMembership.jsonld diff --git a/app/controllers/ElementController.java b/app/controllers/ElementController.java index f0052d6a..78f6177b 100644 --- a/app/controllers/ElementController.java +++ b/app/controllers/ElementController.java @@ -75,7 +75,7 @@ private Result buildPaginatedResult(List elements, UUID projectId, UUID return paginateResult( buildResult(elements, List.class, metamodelProvider.getImplementationClass(Element.class), request, new DataJsonLdAdorner.Parameters(projectId, commitId)), elements.size(), - idx -> elements.get(idx).getIdentifier(), + idx -> elements.get(idx).getElementId(), request, pageRequest ); diff --git a/app/controllers/RelationshipController.java b/app/controllers/RelationshipController.java index 582e28a6..eb2945f8 100644 --- a/app/controllers/RelationshipController.java +++ b/app/controllers/RelationshipController.java @@ -75,7 +75,7 @@ private Result buildPaginatedResult(List relationships, UUID proje return paginateResult( buildResult(relationships, List.class, metamodelProvider.getImplementationClass(Relationship.class), request, new DataJsonLdAdorner.Parameters(projectId, commitId)), relationships.size(), - idx -> relationships.get(idx).getIdentifier(), + idx -> relationships.get(idx).getElementId(), request, pageRequest ); diff --git a/app/dao/impl/jpa/JpaCommitDao.java b/app/dao/impl/jpa/JpaCommitDao.java index 7e1fbc40..e1960487 100644 --- a/app/dao/impl/jpa/JpaCommitDao.java +++ b/app/dao/impl/jpa/JpaCommitDao.java @@ -192,7 +192,11 @@ public void setId(UUID id) { return cacheResolver.apply(data, identifierToDataMap) .map(fnData -> fnData != tombstone ? fnData : null) .orElseGet(() -> { - Data resolved = commitResolver.apply(data, commit.getPreviousCommit()); + Commit previousCommit = commit.getPreviousCommit(); + if (previousCommit == null) { + return null; + } + Data resolved = commitResolver.apply(data, previousCommit); identifierToDataMap.put(resolved.getId(), resolved); return resolved; }); diff --git a/app/dao/impl/jpa/JpaElementDao.java b/app/dao/impl/jpa/JpaElementDao.java index b554b909..c168d7a5 100644 --- a/app/dao/impl/jpa/JpaElementDao.java +++ b/app/dao/impl/jpa/JpaElementDao.java @@ -74,7 +74,7 @@ public Optional findById(UUID id) { CriteriaQuery query = builder.createQuery(ElementImpl.class); Root root = query.from(ElementImpl.class); query.select(root).where(builder.and( - builder.equal(root.get(ElementImpl_.identifier), id), + builder.equal(root.get(ElementImpl_.elementId), id), getTypeExpression(builder, root) )); try { @@ -106,7 +106,7 @@ public List findAll(@Nullable UUID after, @Nullable UUID before, int ma Root root = query.from(ElementImpl.class); query.select(root); Expression where = getTypeExpression(builder, root); - Paginated> paginated = paginateQuery(after, before, maxResults, query, builder, em, root.get(ElementImpl_.identifier), where); + Paginated> paginated = paginateQuery(after, before, maxResults, query, builder, em, root.get(ElementImpl_.elementId), where); List result = paginated.get() .getResultStream() .map(o -> (Element) o) @@ -198,7 +198,7 @@ public List findRootsByCommit(Commit commit, @Nullable UUID after, @Nul .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); + Paginated> paginatedStream = paginateStream(after, before, maxResults, stream, Element::getElementId); List result = paginatedStream.get() .map(element -> JpaDataDao.resolve(element, Element.class)) .collect(Collectors.toList()); diff --git a/app/dao/impl/jpa/JpaRelationshipDao.java b/app/dao/impl/jpa/JpaRelationshipDao.java index d968aea2..3eb82bc3 100644 --- a/app/dao/impl/jpa/JpaRelationshipDao.java +++ b/app/dao/impl/jpa/JpaRelationshipDao.java @@ -68,7 +68,7 @@ public Optional findById(UUID id) { CriteriaQuery query = builder.createQuery(RelationshipImpl.class); Root root = query.from(RelationshipImpl.class); query.select(root).where(builder.and( - builder.equal(root.get(RelationshipImpl_.identifier), id), + builder.equal(root.get(RelationshipImpl_.elementId), id), getTypeExpression(builder, root) )); try { @@ -98,7 +98,7 @@ public List findAll(@Nullable UUID after, @Nullable UUID before, i Root root = query.from(RelationshipImpl.class); query.select(root); Expression where = getTypeExpression(builder, root); - Paginated> paginated = paginateQuery(after, before, maxResults, query, builder, em, root.get(RelationshipImpl_.identifier), where); + Paginated> paginated = paginateQuery(after, before, maxResults, query, builder, em, root.get(RelationshipImpl_.elementId), where); List result = paginated.get() .getResultStream() .map(o -> (Relationship) o) @@ -146,11 +146,11 @@ public List findAllByCommitRelatedElement(Commit commit, Element r throw new IllegalArgumentException("Unknown RelationshipDirection provided: " + direction.name()); } return related - .map(Element::getIdentifier) - .anyMatch(id -> id.equals(relatedElement.getIdentifier())); + .map(Element::getElementId) + .anyMatch(id -> id.equals(relatedElement.getElementId())); } ); - Paginated> paginatedStream = paginateStream(after, before, maxResults, stream, Relationship::getIdentifier); + Paginated> paginatedStream = paginateStream(after, before, maxResults, stream, Relationship::getElementId); List result = paginatedStream.get() .map(relationship -> JpaDataDao.resolve(relationship, Relationship.class)) .collect(Collectors.toList()); diff --git a/app/org/omg/sysml/lifecycle/impl/package-info.java b/app/org/omg/sysml/lifecycle/impl/package-info.java index 436e7ee2..2f7f2453 100644 --- a/app/org/omg/sysml/lifecycle/impl/package-info.java +++ b/app/org/omg/sysml/lifecycle/impl/package-info.java @@ -131,6 +131,7 @@ @MetaValue(value = "OccurrenceDefinition", targetEntity = OccurrenceDefinitionImpl.class), @MetaValue(value = "OccurrenceUsage", targetEntity = OccurrenceUsageImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), + @MetaValue(value = "OwningMembership", targetEntity = OwningMembershipImpl.class), @MetaValue(value = "Package", targetEntity = PackageImpl.class), @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), diff --git a/app/org/omg/sysml/metamodel/AcceptActionUsage.java b/app/org/omg/sysml/metamodel/AcceptActionUsage.java index 4a9f9688..03845609 100644 --- a/app/org/omg/sysml/metamodel/AcceptActionUsage.java +++ b/app/org/omg/sysml/metamodel/AcceptActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ActionDefinition.java b/app/org/omg/sysml/metamodel/ActionDefinition.java index 048881e1..e3200816 100644 --- a/app/org/omg/sysml/metamodel/ActionDefinition.java +++ b/app/org/omg/sysml/metamodel/ActionDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ActionUsage.java b/app/org/omg/sysml/metamodel/ActionUsage.java index 0b938341..cf059dfe 100644 --- a/app/org/omg/sysml/metamodel/ActionUsage.java +++ b/app/org/omg/sysml/metamodel/ActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ActorMembership.java b/app/org/omg/sysml/metamodel/ActorMembership.java index 8d985711..ca8e222c 100644 --- a/app/org/omg/sysml/metamodel/ActorMembership.java +++ b/app/org/omg/sysml/metamodel/ActorMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AllocationDefinition.java b/app/org/omg/sysml/metamodel/AllocationDefinition.java index cc610faa..046afe13 100644 --- a/app/org/omg/sysml/metamodel/AllocationDefinition.java +++ b/app/org/omg/sysml/metamodel/AllocationDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AllocationUsage.java b/app/org/omg/sysml/metamodel/AllocationUsage.java index fb807a85..5031d9e5 100644 --- a/app/org/omg/sysml/metamodel/AllocationUsage.java +++ b/app/org/omg/sysml/metamodel/AllocationUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AnalysisCaseDefinition.java b/app/org/omg/sysml/metamodel/AnalysisCaseDefinition.java index 904cf9e7..b7f57611 100644 --- a/app/org/omg/sysml/metamodel/AnalysisCaseDefinition.java +++ b/app/org/omg/sysml/metamodel/AnalysisCaseDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AnalysisCaseUsage.java b/app/org/omg/sysml/metamodel/AnalysisCaseUsage.java index 19530bce..5e3d45ae 100644 --- a/app/org/omg/sysml/metamodel/AnalysisCaseUsage.java +++ b/app/org/omg/sysml/metamodel/AnalysisCaseUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AnnotatingElement.java b/app/org/omg/sysml/metamodel/AnnotatingElement.java index 56649cf8..b52ac878 100644 --- a/app/org/omg/sysml/metamodel/AnnotatingElement.java +++ b/app/org/omg/sysml/metamodel/AnnotatingElement.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Annotation.java b/app/org/omg/sysml/metamodel/Annotation.java index d2568c71..7eaa5578 100644 --- a/app/org/omg/sysml/metamodel/Annotation.java +++ b/app/org/omg/sysml/metamodel/Annotation.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AssertConstraintUsage.java b/app/org/omg/sysml/metamodel/AssertConstraintUsage.java index 85c3a812..32116986 100644 --- a/app/org/omg/sysml/metamodel/AssertConstraintUsage.java +++ b/app/org/omg/sysml/metamodel/AssertConstraintUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AssignmentActionUsage.java b/app/org/omg/sysml/metamodel/AssignmentActionUsage.java index 6605c350..ba28fce6 100644 --- a/app/org/omg/sysml/metamodel/AssignmentActionUsage.java +++ b/app/org/omg/sysml/metamodel/AssignmentActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Association.java b/app/org/omg/sysml/metamodel/Association.java index 77985c32..1f91bbf2 100644 --- a/app/org/omg/sysml/metamodel/Association.java +++ b/app/org/omg/sysml/metamodel/Association.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AssociationStructure.java b/app/org/omg/sysml/metamodel/AssociationStructure.java index e0823462..7ceed0bb 100644 --- a/app/org/omg/sysml/metamodel/AssociationStructure.java +++ b/app/org/omg/sysml/metamodel/AssociationStructure.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AttributeDefinition.java b/app/org/omg/sysml/metamodel/AttributeDefinition.java index ec09458c..35615b98 100644 --- a/app/org/omg/sysml/metamodel/AttributeDefinition.java +++ b/app/org/omg/sysml/metamodel/AttributeDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/AttributeUsage.java b/app/org/omg/sysml/metamodel/AttributeUsage.java index 51b9a9e8..17d5df18 100644 --- a/app/org/omg/sysml/metamodel/AttributeUsage.java +++ b/app/org/omg/sysml/metamodel/AttributeUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Behavior.java b/app/org/omg/sysml/metamodel/Behavior.java index 2330aae8..4beaaf4a 100644 --- a/app/org/omg/sysml/metamodel/Behavior.java +++ b/app/org/omg/sysml/metamodel/Behavior.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/BindingConnector.java b/app/org/omg/sysml/metamodel/BindingConnector.java index 1f37b0c7..9ceb2fa5 100644 --- a/app/org/omg/sysml/metamodel/BindingConnector.java +++ b/app/org/omg/sysml/metamodel/BindingConnector.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/BindingConnectorAsUsage.java b/app/org/omg/sysml/metamodel/BindingConnectorAsUsage.java index 48690d73..a20bb8ae 100644 --- a/app/org/omg/sysml/metamodel/BindingConnectorAsUsage.java +++ b/app/org/omg/sysml/metamodel/BindingConnectorAsUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/BooleanExpression.java b/app/org/omg/sysml/metamodel/BooleanExpression.java index e6322653..98c339e2 100644 --- a/app/org/omg/sysml/metamodel/BooleanExpression.java +++ b/app/org/omg/sysml/metamodel/BooleanExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/CalculationDefinition.java b/app/org/omg/sysml/metamodel/CalculationDefinition.java index f19daf87..c80c1ba7 100644 --- a/app/org/omg/sysml/metamodel/CalculationDefinition.java +++ b/app/org/omg/sysml/metamodel/CalculationDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/CalculationUsage.java b/app/org/omg/sysml/metamodel/CalculationUsage.java index 34463d88..8b8bf796 100644 --- a/app/org/omg/sysml/metamodel/CalculationUsage.java +++ b/app/org/omg/sysml/metamodel/CalculationUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/CaseDefinition.java b/app/org/omg/sysml/metamodel/CaseDefinition.java index 706294f7..c26911a0 100644 --- a/app/org/omg/sysml/metamodel/CaseDefinition.java +++ b/app/org/omg/sysml/metamodel/CaseDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/CaseUsage.java b/app/org/omg/sysml/metamodel/CaseUsage.java index 30c2e27f..563e7f21 100644 --- a/app/org/omg/sysml/metamodel/CaseUsage.java +++ b/app/org/omg/sysml/metamodel/CaseUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Class.java b/app/org/omg/sysml/metamodel/Class.java index 33b154d8..ffc07a0e 100644 --- a/app/org/omg/sysml/metamodel/Class.java +++ b/app/org/omg/sysml/metamodel/Class.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Classifier.java b/app/org/omg/sysml/metamodel/Classifier.java index 289f599c..7e89de0d 100644 --- a/app/org/omg/sysml/metamodel/Classifier.java +++ b/app/org/omg/sysml/metamodel/Classifier.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/CollectExpression.java b/app/org/omg/sysml/metamodel/CollectExpression.java index a7604c6e..2ff264ea 100644 --- a/app/org/omg/sysml/metamodel/CollectExpression.java +++ b/app/org/omg/sysml/metamodel/CollectExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Comment.java b/app/org/omg/sysml/metamodel/Comment.java index 7ce8452f..c9f7eeb0 100644 --- a/app/org/omg/sysml/metamodel/Comment.java +++ b/app/org/omg/sysml/metamodel/Comment.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConcernDefinition.java b/app/org/omg/sysml/metamodel/ConcernDefinition.java index 2864f01a..0b7c182e 100644 --- a/app/org/omg/sysml/metamodel/ConcernDefinition.java +++ b/app/org/omg/sysml/metamodel/ConcernDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConcernUsage.java b/app/org/omg/sysml/metamodel/ConcernUsage.java index 9c9701d1..d8e49cba 100644 --- a/app/org/omg/sysml/metamodel/ConcernUsage.java +++ b/app/org/omg/sysml/metamodel/ConcernUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConjugatedPortDefinition.java b/app/org/omg/sysml/metamodel/ConjugatedPortDefinition.java index b6e2a175..eea8b98b 100644 --- a/app/org/omg/sysml/metamodel/ConjugatedPortDefinition.java +++ b/app/org/omg/sysml/metamodel/ConjugatedPortDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConjugatedPortTyping.java b/app/org/omg/sysml/metamodel/ConjugatedPortTyping.java index 55afef57..b196681e 100644 --- a/app/org/omg/sysml/metamodel/ConjugatedPortTyping.java +++ b/app/org/omg/sysml/metamodel/ConjugatedPortTyping.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Conjugation.java b/app/org/omg/sysml/metamodel/Conjugation.java index f2198173..b1b923e7 100644 --- a/app/org/omg/sysml/metamodel/Conjugation.java +++ b/app/org/omg/sysml/metamodel/Conjugation.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConnectionDefinition.java b/app/org/omg/sysml/metamodel/ConnectionDefinition.java index c1297727..6d26876c 100644 --- a/app/org/omg/sysml/metamodel/ConnectionDefinition.java +++ b/app/org/omg/sysml/metamodel/ConnectionDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConnectionUsage.java b/app/org/omg/sysml/metamodel/ConnectionUsage.java index 01ea8320..df588fc3 100644 --- a/app/org/omg/sysml/metamodel/ConnectionUsage.java +++ b/app/org/omg/sysml/metamodel/ConnectionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Connector.java b/app/org/omg/sysml/metamodel/Connector.java index 44b87edd..7aa6e0ce 100644 --- a/app/org/omg/sysml/metamodel/Connector.java +++ b/app/org/omg/sysml/metamodel/Connector.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConnectorAsUsage.java b/app/org/omg/sysml/metamodel/ConnectorAsUsage.java index de8ec136..7a3c61eb 100644 --- a/app/org/omg/sysml/metamodel/ConnectorAsUsage.java +++ b/app/org/omg/sysml/metamodel/ConnectorAsUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConstraintDefinition.java b/app/org/omg/sysml/metamodel/ConstraintDefinition.java index dacc92b8..7071bb36 100644 --- a/app/org/omg/sysml/metamodel/ConstraintDefinition.java +++ b/app/org/omg/sysml/metamodel/ConstraintDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ConstraintUsage.java b/app/org/omg/sysml/metamodel/ConstraintUsage.java index c9e137c7..25dd5579 100644 --- a/app/org/omg/sysml/metamodel/ConstraintUsage.java +++ b/app/org/omg/sysml/metamodel/ConstraintUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ControlNode.java b/app/org/omg/sysml/metamodel/ControlNode.java index ba9b8a61..741a3a3e 100644 --- a/app/org/omg/sysml/metamodel/ControlNode.java +++ b/app/org/omg/sysml/metamodel/ControlNode.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/DataType.java b/app/org/omg/sysml/metamodel/DataType.java index 6ffce830..3ca1197b 100644 --- a/app/org/omg/sysml/metamodel/DataType.java +++ b/app/org/omg/sysml/metamodel/DataType.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/DecisionNode.java b/app/org/omg/sysml/metamodel/DecisionNode.java index 08b5aee6..7cf36494 100644 --- a/app/org/omg/sysml/metamodel/DecisionNode.java +++ b/app/org/omg/sysml/metamodel/DecisionNode.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Definition.java b/app/org/omg/sysml/metamodel/Definition.java index 22c0270a..f0166390 100644 --- a/app/org/omg/sysml/metamodel/Definition.java +++ b/app/org/omg/sysml/metamodel/Definition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Dependency.java b/app/org/omg/sysml/metamodel/Dependency.java index 7c7af855..226e9d81 100644 --- a/app/org/omg/sysml/metamodel/Dependency.java +++ b/app/org/omg/sysml/metamodel/Dependency.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Disjoining.java b/app/org/omg/sysml/metamodel/Disjoining.java index 3b5687d1..380db7a1 100644 --- a/app/org/omg/sysml/metamodel/Disjoining.java +++ b/app/org/omg/sysml/metamodel/Disjoining.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Documentation.java b/app/org/omg/sysml/metamodel/Documentation.java index e3a8feb3..0d0de0b3 100644 --- a/app/org/omg/sysml/metamodel/Documentation.java +++ b/app/org/omg/sysml/metamodel/Documentation.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Element.java b/app/org/omg/sysml/metamodel/Element.java index 52186ecc..5f1a5a0c 100644 --- a/app/org/omg/sysml/metamodel/Element.java +++ b/app/org/omg/sysml/metamodel/Element.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -26,15 +27,13 @@ import java.util.Set; public interface Element extends SysMLType { - Membership getOwningMembership(); + OwningMembership getOwningMembership(); Relationship getOwningRelationship(); - java.util.UUID getIdentifier(); - Namespace getOwningNamespace(); - String getName(); + java.util.UUID getElementId(); List getOwnedRelationship(); @@ -48,11 +47,13 @@ public interface Element extends SysMLType { List getTextualRepresentation(); - String getQualifiedName(); + List getAliasIds(); + + String getShortName(); String getEffectiveName(); - List getAliasId(); + String getName(); - String getHumanId(); + String getQualifiedName(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/ElementFilterMembership.java b/app/org/omg/sysml/metamodel/ElementFilterMembership.java index aeaac783..94dd52fa 100644 --- a/app/org/omg/sysml/metamodel/ElementFilterMembership.java +++ b/app/org/omg/sysml/metamodel/ElementFilterMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -25,6 +26,6 @@ import java.util.List; import java.util.Set; -public interface ElementFilterMembership extends Membership, SysMLType { +public interface ElementFilterMembership extends OwningMembership, SysMLType { Expression getCondition(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/EndFeatureMembership.java b/app/org/omg/sysml/metamodel/EndFeatureMembership.java index 76dcea45..ac5ecdae 100644 --- a/app/org/omg/sysml/metamodel/EndFeatureMembership.java +++ b/app/org/omg/sysml/metamodel/EndFeatureMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/EnumerationDefinition.java b/app/org/omg/sysml/metamodel/EnumerationDefinition.java index 66688a00..5ae0ccd1 100644 --- a/app/org/omg/sysml/metamodel/EnumerationDefinition.java +++ b/app/org/omg/sysml/metamodel/EnumerationDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/EnumerationUsage.java b/app/org/omg/sysml/metamodel/EnumerationUsage.java index 96b22a51..1d045b42 100644 --- a/app/org/omg/sysml/metamodel/EnumerationUsage.java +++ b/app/org/omg/sysml/metamodel/EnumerationUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/EventOccurrenceUsage.java b/app/org/omg/sysml/metamodel/EventOccurrenceUsage.java index 718471d8..7a5025e3 100644 --- a/app/org/omg/sysml/metamodel/EventOccurrenceUsage.java +++ b/app/org/omg/sysml/metamodel/EventOccurrenceUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ExhibitStateUsage.java b/app/org/omg/sysml/metamodel/ExhibitStateUsage.java index aa940674..4b76f65e 100644 --- a/app/org/omg/sysml/metamodel/ExhibitStateUsage.java +++ b/app/org/omg/sysml/metamodel/ExhibitStateUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Expose.java b/app/org/omg/sysml/metamodel/Expose.java index 3c9f8888..4feb4193 100644 --- a/app/org/omg/sysml/metamodel/Expose.java +++ b/app/org/omg/sysml/metamodel/Expose.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Expression.java b/app/org/omg/sysml/metamodel/Expression.java index 05f158c6..1f43b3ba 100644 --- a/app/org/omg/sysml/metamodel/Expression.java +++ b/app/org/omg/sysml/metamodel/Expression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Feature.java b/app/org/omg/sysml/metamodel/Feature.java index 3c3f9217..2526294d 100644 --- a/app/org/omg/sysml/metamodel/Feature.java +++ b/app/org/omg/sysml/metamodel/Feature.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FeatureChainExpression.java b/app/org/omg/sysml/metamodel/FeatureChainExpression.java index 18662bb6..7b456d7f 100644 --- a/app/org/omg/sysml/metamodel/FeatureChainExpression.java +++ b/app/org/omg/sysml/metamodel/FeatureChainExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FeatureChaining.java b/app/org/omg/sysml/metamodel/FeatureChaining.java index 3be2cfe1..dd101261 100644 --- a/app/org/omg/sysml/metamodel/FeatureChaining.java +++ b/app/org/omg/sysml/metamodel/FeatureChaining.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FeatureDirectionKind.java b/app/org/omg/sysml/metamodel/FeatureDirectionKind.java index 2c38427a..f875d651 100644 --- a/app/org/omg/sysml/metamodel/FeatureDirectionKind.java +++ b/app/org/omg/sysml/metamodel/FeatureDirectionKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FeatureMembership.java b/app/org/omg/sysml/metamodel/FeatureMembership.java index 407baa5b..d9c019c4 100644 --- a/app/org/omg/sysml/metamodel/FeatureMembership.java +++ b/app/org/omg/sysml/metamodel/FeatureMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -25,10 +26,8 @@ import java.util.List; import java.util.Set; -public interface FeatureMembership extends Membership, TypeFeaturing, SysMLType { +public interface FeatureMembership extends OwningMembership, TypeFeaturing, SysMLType { Type getOwningType(); - Feature getMemberFeature(); - Feature getOwnedMemberFeature(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/FeatureReferenceExpression.java b/app/org/omg/sysml/metamodel/FeatureReferenceExpression.java index ef2d41c0..16493a3d 100644 --- a/app/org/omg/sysml/metamodel/FeatureReferenceExpression.java +++ b/app/org/omg/sysml/metamodel/FeatureReferenceExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FeatureTyping.java b/app/org/omg/sysml/metamodel/FeatureTyping.java index 50ba085d..3a749947 100644 --- a/app/org/omg/sysml/metamodel/FeatureTyping.java +++ b/app/org/omg/sysml/metamodel/FeatureTyping.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FeatureValue.java b/app/org/omg/sysml/metamodel/FeatureValue.java index 7ab0a1dd..7c31a0a2 100644 --- a/app/org/omg/sysml/metamodel/FeatureValue.java +++ b/app/org/omg/sysml/metamodel/FeatureValue.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -25,7 +26,7 @@ import java.util.List; import java.util.Set; -public interface FeatureValue extends Membership, SysMLType { +public interface FeatureValue extends OwningMembership, SysMLType { Feature getFeatureWithValue(); Expression getValue(); diff --git a/app/org/omg/sysml/metamodel/FlowConnectionUsage.java b/app/org/omg/sysml/metamodel/FlowConnectionUsage.java index 48932a72..6dae8f7a 100644 --- a/app/org/omg/sysml/metamodel/FlowConnectionUsage.java +++ b/app/org/omg/sysml/metamodel/FlowConnectionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ForLoopActionUsage.java b/app/org/omg/sysml/metamodel/ForLoopActionUsage.java index 36fc76ab..1179d9a4 100644 --- a/app/org/omg/sysml/metamodel/ForLoopActionUsage.java +++ b/app/org/omg/sysml/metamodel/ForLoopActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ForkNode.java b/app/org/omg/sysml/metamodel/ForkNode.java index 274b2314..9c1c312b 100644 --- a/app/org/omg/sysml/metamodel/ForkNode.java +++ b/app/org/omg/sysml/metamodel/ForkNode.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/FramedConcernMembership.java b/app/org/omg/sysml/metamodel/FramedConcernMembership.java index 2344fd3b..9a2276fc 100644 --- a/app/org/omg/sysml/metamodel/FramedConcernMembership.java +++ b/app/org/omg/sysml/metamodel/FramedConcernMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Function.java b/app/org/omg/sysml/metamodel/Function.java index 5bbbd0a6..50f00fab 100644 --- a/app/org/omg/sysml/metamodel/Function.java +++ b/app/org/omg/sysml/metamodel/Function.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/IfActionUsage.java b/app/org/omg/sysml/metamodel/IfActionUsage.java index e5c6bb4c..f56ff635 100644 --- a/app/org/omg/sysml/metamodel/IfActionUsage.java +++ b/app/org/omg/sysml/metamodel/IfActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Import.java b/app/org/omg/sysml/metamodel/Import.java index 884bc7e0..a42faafe 100644 --- a/app/org/omg/sysml/metamodel/Import.java +++ b/app/org/omg/sysml/metamodel/Import.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/IncludeUseCaseUsage.java b/app/org/omg/sysml/metamodel/IncludeUseCaseUsage.java index 8f972f9b..b3e6d127 100644 --- a/app/org/omg/sysml/metamodel/IncludeUseCaseUsage.java +++ b/app/org/omg/sysml/metamodel/IncludeUseCaseUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Interaction.java b/app/org/omg/sysml/metamodel/Interaction.java index 95c2703e..931189a6 100644 --- a/app/org/omg/sysml/metamodel/Interaction.java +++ b/app/org/omg/sysml/metamodel/Interaction.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/InterfaceDefinition.java b/app/org/omg/sysml/metamodel/InterfaceDefinition.java index a71e891f..f479b1e2 100644 --- a/app/org/omg/sysml/metamodel/InterfaceDefinition.java +++ b/app/org/omg/sysml/metamodel/InterfaceDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/InterfaceUsage.java b/app/org/omg/sysml/metamodel/InterfaceUsage.java index 292c2e31..c6cacd53 100644 --- a/app/org/omg/sysml/metamodel/InterfaceUsage.java +++ b/app/org/omg/sysml/metamodel/InterfaceUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Invariant.java b/app/org/omg/sysml/metamodel/Invariant.java index 8021de40..ffb7eb30 100644 --- a/app/org/omg/sysml/metamodel/Invariant.java +++ b/app/org/omg/sysml/metamodel/Invariant.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/InvocationExpression.java b/app/org/omg/sysml/metamodel/InvocationExpression.java index d397b494..8ab38db5 100644 --- a/app/org/omg/sysml/metamodel/InvocationExpression.java +++ b/app/org/omg/sysml/metamodel/InvocationExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ItemDefinition.java b/app/org/omg/sysml/metamodel/ItemDefinition.java index d681cde6..6f4a9250 100644 --- a/app/org/omg/sysml/metamodel/ItemDefinition.java +++ b/app/org/omg/sysml/metamodel/ItemDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ItemFeature.java b/app/org/omg/sysml/metamodel/ItemFeature.java index 23650e57..a8296f5b 100644 --- a/app/org/omg/sysml/metamodel/ItemFeature.java +++ b/app/org/omg/sysml/metamodel/ItemFeature.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ItemFlow.java b/app/org/omg/sysml/metamodel/ItemFlow.java index a17628d4..bed49fbe 100644 --- a/app/org/omg/sysml/metamodel/ItemFlow.java +++ b/app/org/omg/sysml/metamodel/ItemFlow.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ItemFlowEnd.java b/app/org/omg/sysml/metamodel/ItemFlowEnd.java index e4a8b7b0..80b24b1e 100644 --- a/app/org/omg/sysml/metamodel/ItemFlowEnd.java +++ b/app/org/omg/sysml/metamodel/ItemFlowEnd.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ItemFlowFeature.java b/app/org/omg/sysml/metamodel/ItemFlowFeature.java index b7b3d908..2bb0bf5b 100644 --- a/app/org/omg/sysml/metamodel/ItemFlowFeature.java +++ b/app/org/omg/sysml/metamodel/ItemFlowFeature.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ItemUsage.java b/app/org/omg/sysml/metamodel/ItemUsage.java index 9bea92b4..95d0ff5f 100644 --- a/app/org/omg/sysml/metamodel/ItemUsage.java +++ b/app/org/omg/sysml/metamodel/ItemUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/JoinNode.java b/app/org/omg/sysml/metamodel/JoinNode.java index aed769d4..e4e4ca7e 100644 --- a/app/org/omg/sysml/metamodel/JoinNode.java +++ b/app/org/omg/sysml/metamodel/JoinNode.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LifeClass.java b/app/org/omg/sysml/metamodel/LifeClass.java index 33643cad..64e4392d 100644 --- a/app/org/omg/sysml/metamodel/LifeClass.java +++ b/app/org/omg/sysml/metamodel/LifeClass.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LiteralBoolean.java b/app/org/omg/sysml/metamodel/LiteralBoolean.java index fe412759..c2c18e64 100644 --- a/app/org/omg/sysml/metamodel/LiteralBoolean.java +++ b/app/org/omg/sysml/metamodel/LiteralBoolean.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LiteralExpression.java b/app/org/omg/sysml/metamodel/LiteralExpression.java index ac9939c3..395db7c5 100644 --- a/app/org/omg/sysml/metamodel/LiteralExpression.java +++ b/app/org/omg/sysml/metamodel/LiteralExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LiteralInfinity.java b/app/org/omg/sysml/metamodel/LiteralInfinity.java index 9f44586e..c7722bd6 100644 --- a/app/org/omg/sysml/metamodel/LiteralInfinity.java +++ b/app/org/omg/sysml/metamodel/LiteralInfinity.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LiteralInteger.java b/app/org/omg/sysml/metamodel/LiteralInteger.java index ad5828b0..9345019a 100644 --- a/app/org/omg/sysml/metamodel/LiteralInteger.java +++ b/app/org/omg/sysml/metamodel/LiteralInteger.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LiteralRational.java b/app/org/omg/sysml/metamodel/LiteralRational.java index 648b33c5..e4ee5bf0 100644 --- a/app/org/omg/sysml/metamodel/LiteralRational.java +++ b/app/org/omg/sysml/metamodel/LiteralRational.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LiteralString.java b/app/org/omg/sysml/metamodel/LiteralString.java index 8c73d7c5..60e15ac6 100644 --- a/app/org/omg/sysml/metamodel/LiteralString.java +++ b/app/org/omg/sysml/metamodel/LiteralString.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/LoopActionUsage.java b/app/org/omg/sysml/metamodel/LoopActionUsage.java index c5c54898..e485cbc7 100644 --- a/app/org/omg/sysml/metamodel/LoopActionUsage.java +++ b/app/org/omg/sysml/metamodel/LoopActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Membership.java b/app/org/omg/sysml/metamodel/Membership.java index 54341bd4..548572f6 100644 --- a/app/org/omg/sysml/metamodel/Membership.java +++ b/app/org/omg/sysml/metamodel/Membership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -26,15 +27,15 @@ import java.util.Set; public interface Membership extends Relationship, SysMLType { - String getMemberName(); + String getMemberElementId(); - String getEffectiveMemberName(); + Namespace getMembershipOwningNamespace(); - Element getMemberElement(); + String getMemberShortName(); - Element getOwnedMemberElement(); + Element getMemberElement(); - Namespace getMembershipOwningNamespace(); + String getMemberName(); VisibilityKind getVisibility(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/MergeNode.java b/app/org/omg/sysml/metamodel/MergeNode.java index 314aee3a..23c262b4 100644 --- a/app/org/omg/sysml/metamodel/MergeNode.java +++ b/app/org/omg/sysml/metamodel/MergeNode.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Metaclass.java b/app/org/omg/sysml/metamodel/Metaclass.java index dd50d002..79370c54 100644 --- a/app/org/omg/sysml/metamodel/Metaclass.java +++ b/app/org/omg/sysml/metamodel/Metaclass.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/MetadataDefinition.java b/app/org/omg/sysml/metamodel/MetadataDefinition.java index 86f67e53..29fc1e97 100644 --- a/app/org/omg/sysml/metamodel/MetadataDefinition.java +++ b/app/org/omg/sysml/metamodel/MetadataDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -25,6 +26,6 @@ import java.util.List; import java.util.Set; -public interface MetadataDefinition extends Definition, ItemDefinition, Metaclass, SysMLType { +public interface MetadataDefinition extends Metaclass, ItemDefinition, SysMLType { } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/MetadataFeature.java b/app/org/omg/sysml/metamodel/MetadataFeature.java index a0616723..5bd50d83 100644 --- a/app/org/omg/sysml/metamodel/MetadataFeature.java +++ b/app/org/omg/sysml/metamodel/MetadataFeature.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/MetadataUsage.java b/app/org/omg/sysml/metamodel/MetadataUsage.java index 3fc3a7ec..f4ee9dce 100644 --- a/app/org/omg/sysml/metamodel/MetadataUsage.java +++ b/app/org/omg/sysml/metamodel/MetadataUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -25,6 +26,6 @@ import java.util.List; import java.util.Set; -public interface MetadataUsage extends ItemUsage, MetadataFeature, Usage, SysMLType { +public interface MetadataUsage extends MetadataFeature, ItemUsage, SysMLType { Metaclass getMetadataDefinition(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/Multiplicity.java b/app/org/omg/sysml/metamodel/Multiplicity.java index 30e1f1a0..c5a2960f 100644 --- a/app/org/omg/sysml/metamodel/Multiplicity.java +++ b/app/org/omg/sysml/metamodel/Multiplicity.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/MultiplicityRange.java b/app/org/omg/sysml/metamodel/MultiplicityRange.java index 3f6ca2f7..6ce96880 100644 --- a/app/org/omg/sysml/metamodel/MultiplicityRange.java +++ b/app/org/omg/sysml/metamodel/MultiplicityRange.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Namespace.java b/app/org/omg/sysml/metamodel/Namespace.java index 3a66570e..c8229d23 100644 --- a/app/org/omg/sysml/metamodel/Namespace.java +++ b/app/org/omg/sysml/metamodel/Namespace.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/NullExpression.java b/app/org/omg/sysml/metamodel/NullExpression.java index 0ad3c981..c7fd7ad0 100644 --- a/app/org/omg/sysml/metamodel/NullExpression.java +++ b/app/org/omg/sysml/metamodel/NullExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ObjectiveMembership.java b/app/org/omg/sysml/metamodel/ObjectiveMembership.java index 2b08cced..8cb2ffd2 100644 --- a/app/org/omg/sysml/metamodel/ObjectiveMembership.java +++ b/app/org/omg/sysml/metamodel/ObjectiveMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/OccurrenceDefinition.java b/app/org/omg/sysml/metamodel/OccurrenceDefinition.java index 26a3fef4..405f47ce 100644 --- a/app/org/omg/sysml/metamodel/OccurrenceDefinition.java +++ b/app/org/omg/sysml/metamodel/OccurrenceDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/OccurrenceUsage.java b/app/org/omg/sysml/metamodel/OccurrenceUsage.java index 075597c9..90bf7aa9 100644 --- a/app/org/omg/sysml/metamodel/OccurrenceUsage.java +++ b/app/org/omg/sysml/metamodel/OccurrenceUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/OperatorExpression.java b/app/org/omg/sysml/metamodel/OperatorExpression.java index d01c1604..8aabde73 100644 --- a/app/org/omg/sysml/metamodel/OperatorExpression.java +++ b/app/org/omg/sysml/metamodel/OperatorExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/OwningMembership.java b/app/org/omg/sysml/metamodel/OwningMembership.java new file mode 100644 index 00000000..844670bf --- /dev/null +++ b/app/org/omg/sysml/metamodel/OwningMembership.java @@ -0,0 +1,37 @@ +/* + * SysML v2 REST/HTTP Pilot Implementation + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC + * + * 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 OwningMembership extends Membership, SysMLType { + Element getOwnedMemberElement(); + + String getOwnedMemberElementId(); + + String getOwnedMemberShortName(); + + String getOwnedMemberName(); +} \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/Package.java b/app/org/omg/sysml/metamodel/Package.java index 027dbc9b..8ec19773 100644 --- a/app/org/omg/sysml/metamodel/Package.java +++ b/app/org/omg/sysml/metamodel/Package.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ParameterMembership.java b/app/org/omg/sysml/metamodel/ParameterMembership.java index aee2a777..5cd196b4 100644 --- a/app/org/omg/sysml/metamodel/ParameterMembership.java +++ b/app/org/omg/sysml/metamodel/ParameterMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -27,6 +28,4 @@ public interface ParameterMembership extends FeatureMembership, SysMLType { Feature getOwnedMemberParameter(); - - Feature getMemberParameter(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/PartDefinition.java b/app/org/omg/sysml/metamodel/PartDefinition.java index c970ef6d..2e223391 100644 --- a/app/org/omg/sysml/metamodel/PartDefinition.java +++ b/app/org/omg/sysml/metamodel/PartDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/PartUsage.java b/app/org/omg/sysml/metamodel/PartUsage.java index 201901fd..c02a13a4 100644 --- a/app/org/omg/sysml/metamodel/PartUsage.java +++ b/app/org/omg/sysml/metamodel/PartUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/PerformActionUsage.java b/app/org/omg/sysml/metamodel/PerformActionUsage.java index cb74cfca..55112ae3 100644 --- a/app/org/omg/sysml/metamodel/PerformActionUsage.java +++ b/app/org/omg/sysml/metamodel/PerformActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/PortConjugation.java b/app/org/omg/sysml/metamodel/PortConjugation.java index a659387b..fe4e8a6f 100644 --- a/app/org/omg/sysml/metamodel/PortConjugation.java +++ b/app/org/omg/sysml/metamodel/PortConjugation.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/PortDefinition.java b/app/org/omg/sysml/metamodel/PortDefinition.java index 37cbb10a..4c52a02a 100644 --- a/app/org/omg/sysml/metamodel/PortDefinition.java +++ b/app/org/omg/sysml/metamodel/PortDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/PortUsage.java b/app/org/omg/sysml/metamodel/PortUsage.java index 9081d4d2..a7d5f7b3 100644 --- a/app/org/omg/sysml/metamodel/PortUsage.java +++ b/app/org/omg/sysml/metamodel/PortUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -27,6 +28,4 @@ public interface PortUsage extends OccurrenceUsage, SysMLType { List getPortDefinition(); - - Usage getPortOwningUsage(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/PortionKind.java b/app/org/omg/sysml/metamodel/PortionKind.java index d1fe6d33..c86a288f 100644 --- a/app/org/omg/sysml/metamodel/PortionKind.java +++ b/app/org/omg/sysml/metamodel/PortionKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/PortioningFeature.java b/app/org/omg/sysml/metamodel/PortioningFeature.java index d71012e4..a75b6a9a 100644 --- a/app/org/omg/sysml/metamodel/PortioningFeature.java +++ b/app/org/omg/sysml/metamodel/PortioningFeature.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Predicate.java b/app/org/omg/sysml/metamodel/Predicate.java index 50ac6164..debf3217 100644 --- a/app/org/omg/sysml/metamodel/Predicate.java +++ b/app/org/omg/sysml/metamodel/Predicate.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Redefinition.java b/app/org/omg/sysml/metamodel/Redefinition.java index c6d1ce71..2b5213b1 100644 --- a/app/org/omg/sysml/metamodel/Redefinition.java +++ b/app/org/omg/sysml/metamodel/Redefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ReferenceUsage.java b/app/org/omg/sysml/metamodel/ReferenceUsage.java index 41ed39a9..75aa813b 100644 --- a/app/org/omg/sysml/metamodel/ReferenceUsage.java +++ b/app/org/omg/sysml/metamodel/ReferenceUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Relationship.java b/app/org/omg/sysml/metamodel/Relationship.java index ba202ef2..7cd24e5d 100644 --- a/app/org/omg/sysml/metamodel/Relationship.java +++ b/app/org/omg/sysml/metamodel/Relationship.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RenderingDefinition.java b/app/org/omg/sysml/metamodel/RenderingDefinition.java index 425a98be..87c8b81c 100644 --- a/app/org/omg/sysml/metamodel/RenderingDefinition.java +++ b/app/org/omg/sysml/metamodel/RenderingDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RenderingUsage.java b/app/org/omg/sysml/metamodel/RenderingUsage.java index 6fbe426b..18b12a06 100644 --- a/app/org/omg/sysml/metamodel/RenderingUsage.java +++ b/app/org/omg/sysml/metamodel/RenderingUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RequirementConstraintKind.java b/app/org/omg/sysml/metamodel/RequirementConstraintKind.java index ba0a09b7..a7d043a7 100644 --- a/app/org/omg/sysml/metamodel/RequirementConstraintKind.java +++ b/app/org/omg/sysml/metamodel/RequirementConstraintKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RequirementConstraintMembership.java b/app/org/omg/sysml/metamodel/RequirementConstraintMembership.java index 44c1247e..4192bedd 100644 --- a/app/org/omg/sysml/metamodel/RequirementConstraintMembership.java +++ b/app/org/omg/sysml/metamodel/RequirementConstraintMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RequirementDefinition.java b/app/org/omg/sysml/metamodel/RequirementDefinition.java index 32af6b3b..6959acf5 100644 --- a/app/org/omg/sysml/metamodel/RequirementDefinition.java +++ b/app/org/omg/sysml/metamodel/RequirementDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RequirementUsage.java b/app/org/omg/sysml/metamodel/RequirementUsage.java index b81cd99c..b116dc47 100644 --- a/app/org/omg/sysml/metamodel/RequirementUsage.java +++ b/app/org/omg/sysml/metamodel/RequirementUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/RequirementVerificationMembership.java b/app/org/omg/sysml/metamodel/RequirementVerificationMembership.java index 4efad73a..7ed45be4 100644 --- a/app/org/omg/sysml/metamodel/RequirementVerificationMembership.java +++ b/app/org/omg/sysml/metamodel/RequirementVerificationMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ResultExpressionMembership.java b/app/org/omg/sysml/metamodel/ResultExpressionMembership.java index e581d75b..7d5d7146 100644 --- a/app/org/omg/sysml/metamodel/ResultExpressionMembership.java +++ b/app/org/omg/sysml/metamodel/ResultExpressionMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ReturnParameterMembership.java b/app/org/omg/sysml/metamodel/ReturnParameterMembership.java index 3061156d..686cc6cb 100644 --- a/app/org/omg/sysml/metamodel/ReturnParameterMembership.java +++ b/app/org/omg/sysml/metamodel/ReturnParameterMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SatisfyRequirementUsage.java b/app/org/omg/sysml/metamodel/SatisfyRequirementUsage.java index 0a57aee6..886c4c7c 100644 --- a/app/org/omg/sysml/metamodel/SatisfyRequirementUsage.java +++ b/app/org/omg/sysml/metamodel/SatisfyRequirementUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SelectExpression.java b/app/org/omg/sysml/metamodel/SelectExpression.java index 0e62089c..e6603465 100644 --- a/app/org/omg/sysml/metamodel/SelectExpression.java +++ b/app/org/omg/sysml/metamodel/SelectExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SendActionUsage.java b/app/org/omg/sysml/metamodel/SendActionUsage.java index 9272cf40..61f75085 100644 --- a/app/org/omg/sysml/metamodel/SendActionUsage.java +++ b/app/org/omg/sysml/metamodel/SendActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SourceEnd.java b/app/org/omg/sysml/metamodel/SourceEnd.java index b9243ba6..22a77d29 100644 --- a/app/org/omg/sysml/metamodel/SourceEnd.java +++ b/app/org/omg/sysml/metamodel/SourceEnd.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Specialization.java b/app/org/omg/sysml/metamodel/Specialization.java index 7ea0bed4..67e626bb 100644 --- a/app/org/omg/sysml/metamodel/Specialization.java +++ b/app/org/omg/sysml/metamodel/Specialization.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/StakeholderMembership.java b/app/org/omg/sysml/metamodel/StakeholderMembership.java index 1ed5a8b1..c2bf6f32 100644 --- a/app/org/omg/sysml/metamodel/StakeholderMembership.java +++ b/app/org/omg/sysml/metamodel/StakeholderMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/StateDefinition.java b/app/org/omg/sysml/metamodel/StateDefinition.java index 1cca484f..1c54c70d 100644 --- a/app/org/omg/sysml/metamodel/StateDefinition.java +++ b/app/org/omg/sysml/metamodel/StateDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/StateSubactionKind.java b/app/org/omg/sysml/metamodel/StateSubactionKind.java index 8eaa4be0..1344ab61 100644 --- a/app/org/omg/sysml/metamodel/StateSubactionKind.java +++ b/app/org/omg/sysml/metamodel/StateSubactionKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/StateSubactionMembership.java b/app/org/omg/sysml/metamodel/StateSubactionMembership.java index b5abcdf1..0d1c498e 100644 --- a/app/org/omg/sysml/metamodel/StateSubactionMembership.java +++ b/app/org/omg/sysml/metamodel/StateSubactionMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/StateUsage.java b/app/org/omg/sysml/metamodel/StateUsage.java index acfa094d..7afdb041 100644 --- a/app/org/omg/sysml/metamodel/StateUsage.java +++ b/app/org/omg/sysml/metamodel/StateUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Step.java b/app/org/omg/sysml/metamodel/Step.java index b8a310aa..9bc53e84 100644 --- a/app/org/omg/sysml/metamodel/Step.java +++ b/app/org/omg/sysml/metamodel/Step.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Structure.java b/app/org/omg/sysml/metamodel/Structure.java index d406acfa..9b8ee24e 100644 --- a/app/org/omg/sysml/metamodel/Structure.java +++ b/app/org/omg/sysml/metamodel/Structure.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Subclassification.java b/app/org/omg/sysml/metamodel/Subclassification.java index 85bd6613..e2f9a48e 100644 --- a/app/org/omg/sysml/metamodel/Subclassification.java +++ b/app/org/omg/sysml/metamodel/Subclassification.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SubjectMembership.java b/app/org/omg/sysml/metamodel/SubjectMembership.java index c20af2ff..f5a7058a 100644 --- a/app/org/omg/sysml/metamodel/SubjectMembership.java +++ b/app/org/omg/sysml/metamodel/SubjectMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Subsetting.java b/app/org/omg/sysml/metamodel/Subsetting.java index d0676fe1..d0ce48b4 100644 --- a/app/org/omg/sysml/metamodel/Subsetting.java +++ b/app/org/omg/sysml/metamodel/Subsetting.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Succession.java b/app/org/omg/sysml/metamodel/Succession.java index 5c8ee1a5..dbdc4ed8 100644 --- a/app/org/omg/sysml/metamodel/Succession.java +++ b/app/org/omg/sysml/metamodel/Succession.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SuccessionAsUsage.java b/app/org/omg/sysml/metamodel/SuccessionAsUsage.java index 41817b90..3afc84bd 100644 --- a/app/org/omg/sysml/metamodel/SuccessionAsUsage.java +++ b/app/org/omg/sysml/metamodel/SuccessionAsUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SuccessionFlowConnectionUsage.java b/app/org/omg/sysml/metamodel/SuccessionFlowConnectionUsage.java index 1cc0ff54..3146a89a 100644 --- a/app/org/omg/sysml/metamodel/SuccessionFlowConnectionUsage.java +++ b/app/org/omg/sysml/metamodel/SuccessionFlowConnectionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/SuccessionItemFlow.java b/app/org/omg/sysml/metamodel/SuccessionItemFlow.java index 63631697..e3eeef9d 100644 --- a/app/org/omg/sysml/metamodel/SuccessionItemFlow.java +++ b/app/org/omg/sysml/metamodel/SuccessionItemFlow.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TargetEnd.java b/app/org/omg/sysml/metamodel/TargetEnd.java index f227876f..d8f491b3 100644 --- a/app/org/omg/sysml/metamodel/TargetEnd.java +++ b/app/org/omg/sysml/metamodel/TargetEnd.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TextualRepresentation.java b/app/org/omg/sysml/metamodel/TextualRepresentation.java index fb5de50f..22b02e32 100644 --- a/app/org/omg/sysml/metamodel/TextualRepresentation.java +++ b/app/org/omg/sysml/metamodel/TextualRepresentation.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TransitionFeatureKind.java b/app/org/omg/sysml/metamodel/TransitionFeatureKind.java index 3eebeab3..b52aaf7c 100644 --- a/app/org/omg/sysml/metamodel/TransitionFeatureKind.java +++ b/app/org/omg/sysml/metamodel/TransitionFeatureKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TransitionFeatureMembership.java b/app/org/omg/sysml/metamodel/TransitionFeatureMembership.java index 1dab66ac..3296d4ba 100644 --- a/app/org/omg/sysml/metamodel/TransitionFeatureMembership.java +++ b/app/org/omg/sysml/metamodel/TransitionFeatureMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TransitionUsage.java b/app/org/omg/sysml/metamodel/TransitionUsage.java index c611a565..40ab62db 100644 --- a/app/org/omg/sysml/metamodel/TransitionUsage.java +++ b/app/org/omg/sysml/metamodel/TransitionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TriggerInvocationExpression.java b/app/org/omg/sysml/metamodel/TriggerInvocationExpression.java index a1c91633..4d63191b 100644 --- a/app/org/omg/sysml/metamodel/TriggerInvocationExpression.java +++ b/app/org/omg/sysml/metamodel/TriggerInvocationExpression.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/TriggerKind.java b/app/org/omg/sysml/metamodel/TriggerKind.java index 455e4c28..cf988b1d 100644 --- a/app/org/omg/sysml/metamodel/TriggerKind.java +++ b/app/org/omg/sysml/metamodel/TriggerKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Type.java b/app/org/omg/sysml/metamodel/Type.java index cd3ab279..47d1aeb1 100644 --- a/app/org/omg/sysml/metamodel/Type.java +++ b/app/org/omg/sysml/metamodel/Type.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -52,8 +53,6 @@ public interface Type extends Namespace, SysMLType { Boolean getIsConjugated(); - List getFeatureMembership(); - List getInheritedFeature(); Multiplicity getMultiplicity(); @@ -61,4 +60,6 @@ public interface Type extends Namespace, SysMLType { List getDirectedFeature(); Collection getOwnedDisjoining(); + + List getFeatureMembership(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/TypeFeaturing.java b/app/org/omg/sysml/metamodel/TypeFeaturing.java index 271f2e44..4d0c365a 100644 --- a/app/org/omg/sysml/metamodel/TypeFeaturing.java +++ b/app/org/omg/sysml/metamodel/TypeFeaturing.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/Usage.java b/app/org/omg/sysml/metamodel/Usage.java index 44625ee0..efd65dc2 100644 --- a/app/org/omg/sysml/metamodel/Usage.java +++ b/app/org/omg/sysml/metamodel/Usage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/UseCaseDefinition.java b/app/org/omg/sysml/metamodel/UseCaseDefinition.java index e99b42f6..abb58a46 100644 --- a/app/org/omg/sysml/metamodel/UseCaseDefinition.java +++ b/app/org/omg/sysml/metamodel/UseCaseDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/UseCaseUsage.java b/app/org/omg/sysml/metamodel/UseCaseUsage.java index f78c5494..30ebd8f8 100644 --- a/app/org/omg/sysml/metamodel/UseCaseUsage.java +++ b/app/org/omg/sysml/metamodel/UseCaseUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/VariantMembership.java b/app/org/omg/sysml/metamodel/VariantMembership.java index fedb682e..5a96de36 100644 --- a/app/org/omg/sysml/metamodel/VariantMembership.java +++ b/app/org/omg/sysml/metamodel/VariantMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -25,6 +26,6 @@ import java.util.List; import java.util.Set; -public interface VariantMembership extends Membership, SysMLType { +public interface VariantMembership extends OwningMembership, SysMLType { Usage getOwnedVariantUsage(); } \ No newline at end of file diff --git a/app/org/omg/sysml/metamodel/VerificationCaseDefinition.java b/app/org/omg/sysml/metamodel/VerificationCaseDefinition.java index 3dad2b39..90c82553 100644 --- a/app/org/omg/sysml/metamodel/VerificationCaseDefinition.java +++ b/app/org/omg/sysml/metamodel/VerificationCaseDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/VerificationCaseUsage.java b/app/org/omg/sysml/metamodel/VerificationCaseUsage.java index 02958c37..72640f4f 100644 --- a/app/org/omg/sysml/metamodel/VerificationCaseUsage.java +++ b/app/org/omg/sysml/metamodel/VerificationCaseUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ViewDefinition.java b/app/org/omg/sysml/metamodel/ViewDefinition.java index 7d253c56..8ea395ec 100644 --- a/app/org/omg/sysml/metamodel/ViewDefinition.java +++ b/app/org/omg/sysml/metamodel/ViewDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ViewRenderingMembership.java b/app/org/omg/sysml/metamodel/ViewRenderingMembership.java index b3cc0b3d..e4c531e0 100644 --- a/app/org/omg/sysml/metamodel/ViewRenderingMembership.java +++ b/app/org/omg/sysml/metamodel/ViewRenderingMembership.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ViewUsage.java b/app/org/omg/sysml/metamodel/ViewUsage.java index 64384450..b29e37b3 100644 --- a/app/org/omg/sysml/metamodel/ViewUsage.java +++ b/app/org/omg/sysml/metamodel/ViewUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ViewpointDefinition.java b/app/org/omg/sysml/metamodel/ViewpointDefinition.java index ecc8556f..fc4f0487 100644 --- a/app/org/omg/sysml/metamodel/ViewpointDefinition.java +++ b/app/org/omg/sysml/metamodel/ViewpointDefinition.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/ViewpointUsage.java b/app/org/omg/sysml/metamodel/ViewpointUsage.java index a07a3b01..6466e5ad 100644 --- a/app/org/omg/sysml/metamodel/ViewpointUsage.java +++ b/app/org/omg/sysml/metamodel/ViewpointUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/VisibilityKind.java b/app/org/omg/sysml/metamodel/VisibilityKind.java index 7f433669..c252c5e5 100644 --- a/app/org/omg/sysml/metamodel/VisibilityKind.java +++ b/app/org/omg/sysml/metamodel/VisibilityKind.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/WhileLoopActionUsage.java b/app/org/omg/sysml/metamodel/WhileLoopActionUsage.java index 2a36bf7f..36b4d1a5 100644 --- a/app/org/omg/sysml/metamodel/WhileLoopActionUsage.java +++ b/app/org/omg/sysml/metamodel/WhileLoopActionUsage.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 diff --git a/app/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl.java index 7e942283..def48a6e 100644 --- a/app/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class AcceptActionUsageImpl extends SysMLTypeImpl implements AcceptAction @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AcceptActionUsage_aliasId", - joinColumns = @JoinColumn(name = "AcceptActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AcceptActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "AcceptActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AcceptActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "AcceptActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "AcceptActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "AcceptActionUsage") - 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 = "AcceptActionUsage") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "AcceptActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "AcceptActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AcceptActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AcceptActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "AcceptActionUsage") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AcceptActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AcceptActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AcceptActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AcceptActionUsage") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "AcceptActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "AcceptActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "AcceptActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "AcceptActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AcceptActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AcceptActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AcceptActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AcceptActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "AcceptActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AcceptActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "AcceptActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "AcceptActionUsage") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "AcceptActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "AcceptActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2277,8 +2258,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "payloadArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "payloadArgumentId", table = "AcceptActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "payloadArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "payloadArgument_id", table = "AcceptActionUsage") public Expression getPayloadArgument() { return payloadArgument; } @@ -2298,8 +2279,8 @@ public void setPayloadArgument(Expression payloadArgument) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "payloadParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "payloadParameterId", table = "AcceptActionUsage") + @Any(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "payloadParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "payloadParameter_id", table = "AcceptActionUsage") public ReferenceUsage getPayloadParameter() { return payloadParameter; } @@ -2337,8 +2318,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "AcceptActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "AcceptActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2378,8 +2359,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "receiverArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "receiverArgumentId", table = "AcceptActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "receiverArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "receiverArgument_id", table = "AcceptActionUsage") public Expression getReceiverArgument() { return receiverArgument; } @@ -2392,6 +2373,24 @@ public void setReceiverArgument(Expression receiverArgument) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AcceptActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2399,10 +2398,10 @@ public void setReceiverArgument(Expression receiverArgument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2425,10 +2424,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2451,10 +2450,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2477,10 +2476,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2503,10 +2502,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AcceptActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ActionDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ActionDefinitionImpl.java index 49696ee0..e5c196b0 100644 --- a/app/org/omg/sysml/metamodel/impl/ActionDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ActionDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ActionDefinitionImpl extends SysMLTypeImpl implements ActionDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setAction(List action) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ActionDefinition_aliasId", - joinColumns = @JoinColumn(name = "ActionDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ActionDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ActionDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -216,6 +217,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ActionDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -223,10 +240,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -294,40 +311,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "ActionDefinition") - 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 = "ActionDefinition") - 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; @@ -335,10 +318,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -521,8 +504,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ActionDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ActionDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -542,10 +525,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -568,10 +551,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -594,8 +577,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ActionDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ActionDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -608,14 +591,12 @@ public void setMultiplicity(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 = "ActionDefinition") public String getName() { return name; @@ -635,10 +616,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -843,10 +824,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -869,8 +850,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ActionDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ActionDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -890,10 +871,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1642,10 +1623,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1668,8 +1649,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ActionDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ActionDefinition") public Element getOwner() { return owner; } @@ -1683,19 +1664,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ActionDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ActionDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1708,8 +1689,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ActionDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ActionDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1727,8 +1708,8 @@ 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 = "ActionDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ActionDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1748,10 +1729,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1787,6 +1768,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ActionDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1794,10 +1793,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1846,10 +1845,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1872,10 +1871,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1898,10 +1897,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ActionUsageImpl.java index f3440125..d57508c3 100644 --- a/app/org/omg/sysml/metamodel/impl/ActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ActionUsageImpl extends SysMLTypeImpl implements ActionUsage { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ActionUsage_aliasId", - joinColumns = @JoinColumn(name = "ActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "ActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ActionUsage") - 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 = "ActionUsage") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "ActionUsage") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ActionUsage") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "ActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ActionUsage") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2329,6 +2310,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2336,10 +2335,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ActorMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ActorMembershipImpl.java index a5d145bc..0a6aa699 100644 --- a/app/org/omg/sysml/metamodel/impl/ActorMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ActorMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ActorMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ActorMembershipImpl extends SysMLTypeImpl implements ActorMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ActorMembership_aliasId", - joinColumns = @JoinColumn(name = "ActorMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ActorMembership_aliasIds", + joinColumns = @JoinColumn(name = "ActorMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "ActorMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "ActorMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "ActorMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "ActorMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "ActorMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "ActorMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "ActorMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "ActorMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "ActorMembership") - 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 = "ActorMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ActorMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ActorMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "ActorMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ActorMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,21 +250,20 @@ public void setMemberName(String memberName) { - // @info.archinnov.achilles.annotations.Column("memberParameter") - private Feature memberParameter; + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberParameterId", table = "ActorMembership") - public Feature getMemberParameter() { - return memberParameter; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ActorMembership") + public String getMemberShortName() { + return memberShortName; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberParameter(Feature memberParameter) { - this.memberParameter = memberParameter; + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; } @@ -312,8 +275,8 @@ public void setMemberParameter(Feature memberParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ActorMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ActorMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -326,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ActorMembership") public String getName() { return name; @@ -351,8 +312,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedActorParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedActorParameterId", table = "ActorMembership") + @Any(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedActorParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedActorParameter_id", table = "ActorMembership") public PartUsage getOwnedActorParameter() { return ownedActorParameter; } @@ -372,10 +333,10 @@ public void setOwnedActorParameter(PartUsage ownedActorParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -398,10 +359,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -422,8 +383,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ActorMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ActorMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -436,13 +397,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ActorMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "ActorMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "ActorMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -455,13 +436,33 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ActorMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberParameter") private Feature ownedMemberParameter; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberParameterId", table = "ActorMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberParameter_id", table = "ActorMembership") public Feature getOwnedMemberParameter() { return ownedMemberParameter; } @@ -474,15 +475,35 @@ public void setOwnedMemberParameter(Feature ownedMemberParameter) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ActorMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -503,10 +524,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -529,8 +550,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ActorMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ActorMembership") public Element getOwner() { return owner; } @@ -550,8 +571,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "ActorMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "ActorMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -565,19 +586,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ActorMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ActorMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -590,8 +611,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ActorMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ActorMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -609,8 +630,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ActorMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ActorMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -628,8 +649,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ActorMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ActorMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -649,8 +670,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ActorMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ActorMembership") public Type getOwningType() { return owningType; } @@ -690,10 +711,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -709,15 +730,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ActorMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -738,10 +777,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -764,10 +803,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ActorMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl.java index 06c3aefe..c39428c8 100644 --- a/app/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AllocationDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AllocationDefinitionImpl extends SysMLTypeImpl implements AllocationDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AllocationDefinition_aliasId", - joinColumns = @JoinColumn(name = "AllocationDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AllocationDefinition_aliasIds", + joinColumns = @JoinColumn(name = "AllocationDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_allocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAllocation() { if (allocation == null) { allocation = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAllocation(List allocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_associationEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociationEnd() { if (associationEnd == null) { associationEnd = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssociationEnd(Collection associationEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_connectionEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionEnd() { if (connectionEnd == null) { connectionEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectionEnd(List connectionEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -268,6 +269,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AllocationDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -275,10 +292,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -346,40 +363,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "AllocationDefinition") - 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 = "AllocationDefinition") - 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; @@ -387,10 +370,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -573,8 +556,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "AllocationDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "AllocationDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -594,10 +577,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -620,10 +603,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -646,8 +629,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AllocationDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AllocationDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -660,14 +643,12 @@ public void setMultiplicity(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 = "AllocationDefinition") public String getName() { return name; @@ -687,10 +668,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -843,10 +824,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -869,10 +850,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -895,10 +876,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -921,8 +902,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AllocationDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AllocationDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -942,10 +923,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1432,10 +1413,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1458,10 +1439,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1484,10 +1465,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1510,10 +1491,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1536,10 +1517,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1562,10 +1543,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1588,10 +1569,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1614,10 +1595,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1640,10 +1621,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1666,10 +1647,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1692,10 +1673,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1718,10 +1699,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1744,8 +1725,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AllocationDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AllocationDefinition") public Element getOwner() { return owner; } @@ -1759,19 +1740,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AllocationDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AllocationDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1784,8 +1765,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AllocationDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AllocationDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1803,8 +1784,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "AllocationDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "AllocationDefinition") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1822,8 +1803,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "AllocationDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AllocationDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1863,10 +1844,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1889,10 +1870,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_relatedType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedType() { if (relatedType == null) { relatedType = new ArrayList<>(); @@ -1908,15 +1889,33 @@ public void setRelatedType(List relatedType) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AllocationDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1939,8 +1938,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceTypeId", table = "AllocationDefinition") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceType_id", table = "AllocationDefinition") public Type getSourceType() { return sourceType; } @@ -1958,10 +1957,10 @@ public void setSourceType(Type sourceType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1984,10 +1983,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_targetType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetType() { if (targetType == null) { targetType = new ArrayList<>(); @@ -2010,10 +2009,10 @@ public void setTargetType(Collection targetType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2036,10 +2035,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2062,10 +2061,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2088,10 +2087,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AllocationUsageImpl.java b/app/org/omg/sysml/metamodel/impl/AllocationUsageImpl.java index eeac090f..5f6bc231 100644 --- a/app/org/omg/sysml/metamodel/impl/AllocationUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AllocationUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AllocationUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AllocationUsageImpl extends SysMLTypeImpl implements AllocationUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AllocationUsage_aliasId", - joinColumns = @JoinColumn(name = "AllocationUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AllocationUsage_aliasIds", + joinColumns = @JoinColumn(name = "AllocationUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_allocationDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAllocationDefinition() { if (allocationDefinition == null) { allocationDefinition = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAllocationDefinition(List allocationDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_connectionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionDefinition() { if (connectionDefinition == null) { connectionDefinition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectionDefinition(List connectionDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -255,10 +256,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -281,10 +282,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -325,10 +326,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -364,6 +365,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AllocationUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -371,10 +388,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -397,8 +414,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "AllocationUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "AllocationUsage") public Type getEndOwningType() { return endOwningType; } @@ -418,10 +435,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -470,10 +487,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -489,40 +506,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "AllocationUsage") - 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 = "AllocationUsage") - 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; @@ -530,10 +513,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -556,8 +539,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "AllocationUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "AllocationUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -577,10 +560,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -603,10 +586,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -629,10 +612,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -901,10 +884,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -927,10 +910,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -953,10 +936,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -979,8 +962,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AllocationUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AllocationUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -993,14 +976,12 @@ public void setMultiplicity(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 = "AllocationUsage") public String getName() { return name; @@ -1020,10 +1001,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1722,10 +1703,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1774,8 +1755,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AllocationUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AllocationUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1795,10 +1776,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1821,10 +1802,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1847,10 +1828,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1873,10 +1854,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1899,10 +1880,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1925,10 +1906,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1951,10 +1932,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2003,10 +1984,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2029,10 +2010,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2053,10 +2034,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -2077,10 +2058,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2103,10 +2084,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2129,10 +2110,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2155,10 +2136,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2181,10 +2162,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2207,8 +2188,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AllocationUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AllocationUsage") public Element getOwner() { return owner; } @@ -2228,8 +2209,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "AllocationUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "AllocationUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2247,8 +2228,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "AllocationUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "AllocationUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2262,19 +2243,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AllocationUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AllocationUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2287,8 +2268,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AllocationUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AllocationUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2306,8 +2287,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "AllocationUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "AllocationUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2325,8 +2306,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "AllocationUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AllocationUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2346,8 +2327,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "AllocationUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "AllocationUsage") public Type getOwningType() { return owningType; } @@ -2367,8 +2348,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "AllocationUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "AllocationUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2388,10 +2369,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2432,8 +2413,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "AllocationUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "AllocationUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2473,10 +2454,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2499,10 +2480,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2518,15 +2499,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AllocationUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2549,8 +2548,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "AllocationUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "AllocationUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2568,10 +2567,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2594,10 +2593,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2620,10 +2619,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2646,10 +2645,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2672,10 +2671,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2698,10 +2697,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2724,10 +2723,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AllocationUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl.java index 87db87cc..ee93b665 100644 --- a/app/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class AnalysisCaseDefinitionImpl extends SysMLTypeImpl implements Analysi @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setAction(List action) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AnalysisCaseDefinition_aliasId", - joinColumns = @JoinColumn(name = "AnalysisCaseDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AnalysisCaseDefinition_aliasIds", + joinColumns = @JoinColumn(name = "AnalysisCaseDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_analysisAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnalysisAction() { if (analysisAction == null) { analysisAction = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setAnalysisAction(List analysisAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_calculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getCalculation() { if (calculation == null) { calculation = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setCalculation(List calculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -255,10 +256,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -294,6 +295,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AnalysisCaseDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -301,10 +318,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -379,10 +396,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -398,40 +415,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "AnalysisCaseDefinition") - 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 = "AnalysisCaseDefinition") - 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; @@ -439,10 +422,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -517,10 +500,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -643,8 +626,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "AnalysisCaseDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "AnalysisCaseDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -664,10 +647,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -690,10 +673,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -716,8 +699,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AnalysisCaseDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AnalysisCaseDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -730,14 +713,12 @@ public void setMultiplicity(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 = "AnalysisCaseDefinition") public String getName() { return name; @@ -757,8 +738,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "AnalysisCaseDefinition") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "AnalysisCaseDefinition") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -778,10 +759,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -804,10 +785,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -830,10 +811,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -856,10 +837,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -882,10 +863,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -908,10 +889,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -934,10 +915,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -960,10 +941,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -986,10 +967,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -1012,8 +993,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AnalysisCaseDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AnalysisCaseDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1033,10 +1014,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1059,10 +1040,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1499,10 +1480,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1525,10 +1506,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1551,10 +1532,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1577,10 +1558,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1603,10 +1584,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1629,10 +1610,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1655,10 +1636,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1681,10 +1662,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1707,10 +1688,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1733,10 +1714,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1759,10 +1740,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1785,10 +1766,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1811,8 +1792,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AnalysisCaseDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AnalysisCaseDefinition") public Element getOwner() { return owner; } @@ -1826,19 +1807,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AnalysisCaseDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AnalysisCaseDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1851,8 +1832,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AnalysisCaseDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AnalysisCaseDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1870,8 +1851,8 @@ 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 = "AnalysisCaseDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AnalysisCaseDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1891,10 +1872,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1937,8 +1918,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "AnalysisCaseDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "AnalysisCaseDefinition") public Feature getResult() { return result; } @@ -1958,8 +1939,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "resultExpressionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultExpressionId", table = "AnalysisCaseDefinition") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "resultExpression_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "resultExpression_id", table = "AnalysisCaseDefinition") public Expression getResultExpression() { return resultExpression; } @@ -1972,6 +1953,24 @@ public void setResultExpression(Expression resultExpression) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AnalysisCaseDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1979,10 +1978,10 @@ public void setResultExpression(Expression resultExpression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -2005,8 +2004,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "AnalysisCaseDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "AnalysisCaseDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -2026,10 +2025,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2052,10 +2051,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2078,10 +2077,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2104,10 +2103,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl.java b/app/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl.java index b3a38da2..27bf14cd 100644 --- a/app/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class AnalysisCaseUsageImpl extends SysMLTypeImpl implements AnalysisCase @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setActionDefinition(List actionDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AnalysisCaseUsage_aliasId", - joinColumns = @JoinColumn(name = "AnalysisCaseUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AnalysisCaseUsage_aliasIds", + joinColumns = @JoinColumn(name = "AnalysisCaseUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_analysisAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnalysisAction() { if (analysisAction == null) { analysisAction = new ArrayList<>(); @@ -177,8 +178,8 @@ public void setAnalysisAction(List analysisAction) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "AnalysisCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "analysisCaseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "analysisCaseDefinitionId", table = "AnalysisCaseUsage") + @Any(metaDef = "AnalysisCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "analysisCaseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "analysisCaseDefinition_id", table = "AnalysisCaseUsage") public AnalysisCaseDefinition getAnalysisCaseDefinition() { return analysisCaseDefinition; } @@ -198,10 +199,10 @@ public void setAnalysisCaseDefinition(AnalysisCaseDefinition analysisCaseDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -224,8 +225,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "calculationDefinitionId", table = "AnalysisCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "calculationDefinition_id", table = "AnalysisCaseUsage") public Function getCalculationDefinition() { return calculationDefinition; } @@ -245,8 +246,8 @@ public void setCalculationDefinition(Function calculationDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "caseDefinitionId", table = "AnalysisCaseUsage") + @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "caseDefinition_id", table = "AnalysisCaseUsage") public CaseDefinition getCaseDefinition() { return caseDefinition; } @@ -266,10 +267,10 @@ public void setCaseDefinition(CaseDefinition caseDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -292,10 +293,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -318,10 +319,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -344,10 +345,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -388,10 +389,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -427,6 +428,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AnalysisCaseUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -434,10 +451,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -460,8 +477,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "AnalysisCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "AnalysisCaseUsage") public Type getEndOwningType() { return endOwningType; } @@ -481,10 +498,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -507,10 +524,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -533,10 +550,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -559,8 +576,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "AnalysisCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "AnalysisCaseUsage") public Function getFunction() { return function; } @@ -573,40 +590,6 @@ public void setFunction(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 = "AnalysisCaseUsage") - 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 = "AnalysisCaseUsage") - 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; @@ -614,10 +597,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -640,8 +623,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "AnalysisCaseUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "AnalysisCaseUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -661,10 +644,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -687,10 +670,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -713,10 +696,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -987,10 +970,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -1013,10 +996,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1039,8 +1022,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AnalysisCaseUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AnalysisCaseUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1053,14 +1036,12 @@ public void setMultiplicity(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 = "AnalysisCaseUsage") public String getName() { return name; @@ -1080,10 +1061,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1106,10 +1087,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1132,10 +1113,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1158,10 +1139,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1184,10 +1165,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1210,10 +1191,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1236,10 +1217,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1262,10 +1243,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1288,10 +1269,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1314,10 +1295,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1340,10 +1321,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1366,10 +1347,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1392,10 +1373,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1418,10 +1399,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1444,10 +1425,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1470,10 +1451,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1496,10 +1477,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1522,10 +1503,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1548,10 +1529,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1574,10 +1555,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1600,10 +1581,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1626,10 +1607,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1652,10 +1633,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1678,10 +1659,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1704,10 +1685,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1730,10 +1711,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1756,8 +1737,8 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "AnalysisCaseUsage") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "AnalysisCaseUsage") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -1777,10 +1758,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1803,10 +1784,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1829,10 +1810,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1855,8 +1836,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AnalysisCaseUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AnalysisCaseUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1876,10 +1857,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1902,10 +1883,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1928,10 +1909,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1954,10 +1935,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2058,10 +2039,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2084,10 +2065,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2110,10 +2091,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2134,10 +2115,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2160,10 +2141,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2186,10 +2167,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2212,10 +2193,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2238,10 +2219,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2264,8 +2245,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AnalysisCaseUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AnalysisCaseUsage") public Element getOwner() { return owner; } @@ -2285,8 +2266,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "AnalysisCaseUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "AnalysisCaseUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2304,8 +2285,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "AnalysisCaseUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "AnalysisCaseUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2319,19 +2300,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AnalysisCaseUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AnalysisCaseUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2344,8 +2325,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AnalysisCaseUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AnalysisCaseUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2363,8 +2344,8 @@ 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 = "AnalysisCaseUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AnalysisCaseUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2384,8 +2365,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "AnalysisCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "AnalysisCaseUsage") public Type getOwningType() { return owningType; } @@ -2405,8 +2386,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "AnalysisCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "AnalysisCaseUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2426,10 +2407,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2470,8 +2451,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "AnalysisCaseUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "AnalysisCaseUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2511,8 +2492,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "AnalysisCaseUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "AnalysisCaseUsage") public Feature getResult() { return result; } @@ -2532,8 +2513,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "resultExpressionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultExpressionId", table = "AnalysisCaseUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "resultExpression_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "resultExpression_id", table = "AnalysisCaseUsage") public Expression getResultExpression() { return resultExpression; } @@ -2546,6 +2527,24 @@ public void setResultExpression(Expression resultExpression) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AnalysisCaseUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("subjectParameter") private Usage subjectParameter; @@ -2553,8 +2552,8 @@ public void setResultExpression(Expression resultExpression) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "AnalysisCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "AnalysisCaseUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2574,10 +2573,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2600,10 +2599,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2626,10 +2625,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2652,10 +2651,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2678,10 +2677,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnalysisCaseUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AnnotatingElementImpl.java b/app/org/omg/sysml/metamodel/impl/AnnotatingElementImpl.java index 48fced80..122215d3 100644 --- a/app/org/omg/sysml/metamodel/impl/AnnotatingElementImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AnnotatingElementImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AnnotatingElement") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AnnotatingElementImpl extends SysMLTypeImpl implements AnnotatingElement { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AnnotatingElement_aliasId", - joinColumns = @JoinColumn(name = "AnnotatingElementId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AnnotatingElement_aliasIds", + joinColumns = @JoinColumn(name = "AnnotatingElement_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_annotatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotatedElement() { if (annotatedElement == null) { annotatedElement = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setAnnotatedElement(List annotatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_annotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotation() { if (annotation == null) { annotation = new ArrayList<>(); @@ -149,10 +150,10 @@ public void setAnnotation(List annotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -188,48 +189,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "AnnotatingElement") - 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 = "AnnotatingElement") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "AnnotatingElement") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "AnnotatingElement") public String getName() { return name; @@ -249,10 +230,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -275,10 +256,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -299,10 +280,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -325,8 +306,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AnnotatingElement") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AnnotatingElement") public Element getOwner() { return owner; } @@ -340,19 +321,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AnnotatingElement") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AnnotatingElement") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -365,8 +346,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AnnotatingElement") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AnnotatingElement") public Namespace getOwningNamespace() { return owningNamespace; } @@ -384,8 +365,8 @@ 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 = "AnnotatingElement") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AnnotatingElement") public Relationship getOwningRelationship() { return owningRelationship; } @@ -418,6 +399,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AnnotatingElement") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -425,10 +424,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AnnotatingElement_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AnnotationImpl.java b/app/org/omg/sysml/metamodel/impl/AnnotationImpl.java index 542b871c..ce64289b 100644 --- a/app/org/omg/sysml/metamodel/impl/AnnotationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AnnotationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Annotation") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AnnotationImpl extends SysMLTypeImpl implements Annotation { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Annotation_aliasId", - joinColumns = @JoinColumn(name = "AnnotationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Annotation_aliasIds", + joinColumns = @JoinColumn(name = "Annotation_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -97,8 +98,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "annotatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "annotatedElementId", table = "Annotation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "annotatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "annotatedElement_id", table = "Annotation") public Element getAnnotatedElement() { return annotatedElement; } @@ -116,8 +117,8 @@ public void setAnnotatedElement(Element annotatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "AnnotatingElementMetaDef", metaColumn = @javax.persistence.Column(name = "annotatingElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "annotatingElementId", table = "Annotation") + @Any(metaDef = "AnnotatingElementMetaDef", metaColumn = @javax.persistence.Column(name = "annotatingElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "annotatingElement_id", table = "Annotation") public AnnotatingElement getAnnotatingElement() { return annotatingElement; } @@ -137,10 +138,10 @@ public void setAnnotatingElement(AnnotatingElement annotatingElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -176,48 +177,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Annotation") - 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 = "Annotation") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Annotation") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "Annotation") public String getName() { return name; @@ -237,10 +218,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -263,10 +244,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -287,10 +268,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -311,10 +292,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -337,8 +318,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Annotation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Annotation") public Element getOwner() { return owner; } @@ -356,8 +337,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningAnnotatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningAnnotatedElementId", table = "Annotation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningAnnotatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningAnnotatedElement_id", table = "Annotation") public Element getOwningAnnotatedElement() { return owningAnnotatedElement; } @@ -371,19 +352,19 @@ public void setOwningAnnotatedElement(Element owningAnnotatedElement) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Annotation") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Annotation") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -396,8 +377,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Annotation") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Annotation") public Namespace getOwningNamespace() { return owningNamespace; } @@ -415,8 +396,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Annotation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Annotation") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -434,8 +415,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Annotation") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Annotation") public Relationship getOwningRelationship() { return owningRelationship; } @@ -475,10 +456,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -494,15 +475,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Annotation") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -523,10 +522,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -549,10 +548,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Annotation_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl.java b/app/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl.java index f1786d92..3978b752 100644 --- a/app/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AssertConstraintUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AssertConstraintUsageImpl extends SysMLTypeImpl implements AssertConstraintUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AssertConstraintUsage_aliasId", - joinColumns = @JoinColumn(name = "AssertConstraintUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AssertConstraintUsage_aliasIds", + joinColumns = @JoinColumn(name = "AssertConstraintUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,8 +100,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "assertedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "assertedConstraintId", table = "AssertConstraintUsage") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "assertedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "assertedConstraint_id", table = "AssertConstraintUsage") public ConstraintUsage getAssertedConstraint() { return assertedConstraint; } @@ -120,10 +121,10 @@ public void setAssertedConstraint(ConstraintUsage assertedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -146,10 +147,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -172,8 +173,8 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "constraintDefinitionId", table = "AssertConstraintUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "constraintDefinition_id", table = "AssertConstraintUsage") public Predicate getConstraintDefinition() { return constraintDefinition; } @@ -193,10 +194,10 @@ public void setConstraintDefinition(Predicate constraintDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -219,10 +220,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -245,10 +246,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -289,10 +290,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -328,6 +329,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AssertConstraintUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -335,10 +352,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -361,8 +378,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "AssertConstraintUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "AssertConstraintUsage") public Type getEndOwningType() { return endOwningType; } @@ -382,10 +399,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -408,10 +425,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -434,10 +451,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -460,8 +477,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "AssertConstraintUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "AssertConstraintUsage") public Function getFunction() { return function; } @@ -474,40 +491,6 @@ public void setFunction(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 = "AssertConstraintUsage") - 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 = "AssertConstraintUsage") - 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; @@ -515,10 +498,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -541,8 +524,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "AssertConstraintUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "AssertConstraintUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -562,10 +545,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -588,10 +571,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -614,10 +597,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -904,10 +887,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -930,10 +913,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -956,8 +939,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AssertConstraintUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AssertConstraintUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -970,14 +953,12 @@ public void setMultiplicity(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 = "AssertConstraintUsage") public String getName() { return name; @@ -997,10 +978,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1023,10 +1004,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1049,10 +1030,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1075,10 +1056,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1101,10 +1082,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1127,10 +1108,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1153,10 +1134,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1179,10 +1160,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1205,10 +1186,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1231,10 +1212,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1257,10 +1238,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1283,10 +1264,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1309,10 +1290,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1335,10 +1316,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1361,10 +1342,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1387,10 +1368,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1413,10 +1394,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1439,10 +1420,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1465,10 +1446,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1491,10 +1472,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1517,10 +1498,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1543,10 +1524,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1569,10 +1550,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1595,10 +1576,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1621,10 +1602,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1647,10 +1628,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1673,10 +1654,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1699,10 +1680,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1725,10 +1706,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1751,8 +1732,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AssertConstraintUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AssertConstraintUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1772,10 +1753,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1798,10 +1779,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1824,10 +1805,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1850,10 +1831,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1876,10 +1857,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1902,10 +1883,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1928,10 +1909,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1954,10 +1935,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2030,10 +2011,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2056,10 +2037,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2082,10 +2063,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2108,10 +2089,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2134,10 +2115,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2160,8 +2141,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AssertConstraintUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AssertConstraintUsage") public Element getOwner() { return owner; } @@ -2181,8 +2162,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "AssertConstraintUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "AssertConstraintUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2200,8 +2181,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "AssertConstraintUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "AssertConstraintUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2215,19 +2196,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AssertConstraintUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AssertConstraintUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2240,8 +2221,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AssertConstraintUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AssertConstraintUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2259,8 +2240,8 @@ 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 = "AssertConstraintUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AssertConstraintUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2280,8 +2261,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "AssertConstraintUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "AssertConstraintUsage") public Type getOwningType() { return owningType; } @@ -2301,8 +2282,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "AssertConstraintUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "AssertConstraintUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2322,10 +2303,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2366,8 +2347,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "AssertConstraintUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "AssertConstraintUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2387,8 +2368,8 @@ public void setPortioningFeature(PortioningFeature portioningFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "AssertConstraintUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "AssertConstraintUsage") public Predicate getPredicate() { return predicate; } @@ -2428,8 +2409,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "AssertConstraintUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "AssertConstraintUsage") public Feature getResult() { return result; } @@ -2442,6 +2423,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AssertConstraintUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2449,10 +2448,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2475,10 +2474,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2501,10 +2500,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2527,10 +2526,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2553,10 +2552,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssertConstraintUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl.java index b2cdeeef..0ef7045a 100644 --- a/app/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class AssignmentActionUsageImpl extends SysMLTypeImpl implements Assignme @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AssignmentActionUsage_aliasId", - joinColumns = @JoinColumn(name = "AssignmentActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AssignmentActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "AssignmentActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AssignmentActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "AssignmentActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "AssignmentActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "AssignmentActionUsage") - 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 = "AssignmentActionUsage") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "AssignmentActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "AssignmentActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AssignmentActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AssignmentActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "AssignmentActionUsage") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AssignmentActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AssignmentActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AssignmentActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AssignmentActionUsage") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "AssignmentActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "AssignmentActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "AssignmentActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "AssignmentActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AssignmentActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AssignmentActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AssignmentActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AssignmentActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "AssignmentActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AssignmentActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "AssignmentActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "AssignmentActionUsage") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "AssignmentActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "AssignmentActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "AssignmentActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "AssignmentActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2336,8 +2317,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "referentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referentId", table = "AssignmentActionUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "referent_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referent_id", table = "AssignmentActionUsage") public Feature getReferent() { return referent; } @@ -2350,6 +2331,24 @@ public void setReferent(Feature referent) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AssignmentActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("targetArgument") private Expression targetArgument; @@ -2357,8 +2356,8 @@ public void setReferent(Feature referent) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "targetArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "targetArgumentId", table = "AssignmentActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "targetArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "targetArgument_id", table = "AssignmentActionUsage") public Expression getTargetArgument() { return targetArgument; } @@ -2378,10 +2377,10 @@ public void setTargetArgument(Expression targetArgument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2404,10 +2403,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2430,10 +2429,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2456,8 +2455,8 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "valueExpressionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "valueExpressionId", table = "AssignmentActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "valueExpression_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "valueExpression_id", table = "AssignmentActionUsage") public Expression getValueExpression() { return valueExpression; } @@ -2477,10 +2476,10 @@ public void setValueExpression(Expression valueExpression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2503,10 +2502,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssignmentActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AssociationImpl.java b/app/org/omg/sysml/metamodel/impl/AssociationImpl.java index dfb01e75..0f097a63 100644 --- a/app/org/omg/sysml/metamodel/impl/AssociationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AssociationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Association") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AssociationImpl extends SysMLTypeImpl implements Association { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Association_aliasId", - joinColumns = @JoinColumn(name = "AssociationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Association_aliasIds", + joinColumns = @JoinColumn(name = "Association_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_associationEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociationEnd() { if (associationEnd == null) { associationEnd = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociationEnd(Collection associationEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Association") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Association") - 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 = "Association") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -489,10 +472,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -515,8 +498,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Association") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Association") public Multiplicity getMultiplicity() { return multiplicity; } @@ -529,14 +512,12 @@ public void setMultiplicity(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 = "Association") public String getName() { return name; @@ -556,10 +537,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -582,10 +563,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -608,8 +589,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Association") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Association") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -629,10 +610,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -811,10 +792,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -859,10 +840,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -885,10 +866,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -911,10 +892,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -937,8 +918,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Association") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Association") public Element getOwner() { return owner; } @@ -952,19 +933,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Association") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Association") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -977,8 +958,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Association") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Association") public Namespace getOwningNamespace() { return owningNamespace; } @@ -996,8 +977,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Association") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Association") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1015,8 +996,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Association") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Association") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1056,10 +1037,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_relatedType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedType() { if (relatedType == null) { relatedType = new ArrayList<>(); @@ -1101,15 +1082,33 @@ public void setRelatedType(List relatedType) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Association") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1132,8 +1131,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceTypeId", table = "Association") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceType_id", table = "Association") public Type getSourceType() { return sourceType; } @@ -1151,10 +1150,10 @@ public void setSourceType(Type sourceType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1177,10 +1176,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_targetType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetType() { if (targetType == null) { targetType = new ArrayList<>(); @@ -1203,10 +1202,10 @@ public void setTargetType(Collection targetType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Association_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AssociationStructureImpl.java b/app/org/omg/sysml/metamodel/impl/AssociationStructureImpl.java index 2f6a1460..469f3602 100644 --- a/app/org/omg/sysml/metamodel/impl/AssociationStructureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AssociationStructureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AssociationStructure") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AssociationStructureImpl extends SysMLTypeImpl implements AssociationStructure { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AssociationStructure_aliasId", - joinColumns = @JoinColumn(name = "AssociationStructureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AssociationStructure_aliasIds", + joinColumns = @JoinColumn(name = "AssociationStructure_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_associationEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociationEnd() { if (associationEnd == null) { associationEnd = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociationEnd(Collection associationEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AssociationStructure") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "AssociationStructure") - 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 = "AssociationStructure") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -489,10 +472,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -515,8 +498,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AssociationStructure") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AssociationStructure") public Multiplicity getMultiplicity() { return multiplicity; } @@ -529,14 +512,12 @@ public void setMultiplicity(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 = "AssociationStructure") public String getName() { return name; @@ -556,10 +537,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -582,10 +563,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -608,8 +589,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AssociationStructure") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AssociationStructure") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -629,10 +610,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -811,10 +792,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -859,10 +840,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -885,10 +866,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -911,10 +892,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -937,8 +918,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AssociationStructure") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AssociationStructure") public Element getOwner() { return owner; } @@ -952,19 +933,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AssociationStructure") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AssociationStructure") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -977,8 +958,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AssociationStructure") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AssociationStructure") public Namespace getOwningNamespace() { return owningNamespace; } @@ -996,8 +977,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "AssociationStructure") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "AssociationStructure") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1015,8 +996,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "AssociationStructure") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AssociationStructure") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1056,10 +1037,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_relatedType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedType() { if (relatedType == null) { relatedType = new ArrayList<>(); @@ -1101,15 +1082,33 @@ public void setRelatedType(List relatedType) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AssociationStructure") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1132,8 +1131,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceTypeId", table = "AssociationStructure") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceType_id", table = "AssociationStructure") public Type getSourceType() { return sourceType; } @@ -1151,10 +1150,10 @@ public void setSourceType(Type sourceType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1177,10 +1176,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_targetType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetType() { if (targetType == null) { targetType = new ArrayList<>(); @@ -1203,10 +1202,10 @@ public void setTargetType(Collection targetType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AssociationStructure_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl.java index 7509b7c9..1e8d3234 100644 --- a/app/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AttributeDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AttributeDefinitionImpl extends SysMLTypeImpl implements AttributeDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AttributeDefinition_aliasId", - joinColumns = @JoinColumn(name = "AttributeDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AttributeDefinition_aliasIds", + joinColumns = @JoinColumn(name = "AttributeDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AttributeDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "AttributeDefinition") - 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 = "AttributeDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -479,10 +462,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -505,10 +488,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -531,8 +514,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AttributeDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AttributeDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -545,14 +528,12 @@ public void setMultiplicity(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 = "AttributeDefinition") public String getName() { return name; @@ -572,10 +553,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -598,10 +579,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -624,10 +605,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -650,10 +631,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -676,10 +657,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -702,10 +683,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -728,10 +709,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -754,10 +735,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -780,10 +761,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -806,8 +787,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AttributeDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AttributeDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -827,10 +808,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -853,10 +834,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -879,10 +860,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -905,10 +886,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -931,10 +912,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -957,10 +938,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1165,10 +1146,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1605,8 +1586,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AttributeDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AttributeDefinition") public Element getOwner() { return owner; } @@ -1620,19 +1601,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AttributeDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AttributeDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1645,8 +1626,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AttributeDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AttributeDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1664,8 +1645,8 @@ 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 = "AttributeDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AttributeDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1698,6 +1679,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AttributeDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1705,10 +1704,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1731,10 +1730,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1757,10 +1756,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1783,10 +1782,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/AttributeUsageImpl.java b/app/org/omg/sysml/metamodel/impl/AttributeUsageImpl.java index 2e074c4e..44e15397 100644 --- a/app/org/omg/sysml/metamodel/impl/AttributeUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/AttributeUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "AttributeUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class AttributeUsageImpl extends SysMLTypeImpl implements AttributeUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "AttributeUsage_aliasId", - joinColumns = @JoinColumn(name = "AttributeUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "AttributeUsage_aliasIds", + joinColumns = @JoinColumn(name = "AttributeUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DataTypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DataTypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_attributeDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAttributeDefinition() { if (attributeDefinition == null) { attributeDefinition = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAttributeDefinition(List attributeDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -247,10 +248,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -286,6 +287,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "AttributeUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -293,10 +310,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -319,8 +336,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "AttributeUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "AttributeUsage") public Type getEndOwningType() { return endOwningType; } @@ -340,10 +357,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -411,40 +428,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "AttributeUsage") - 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 = "AttributeUsage") - 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; @@ -452,10 +435,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -530,10 +513,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -768,10 +751,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -794,10 +777,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -820,8 +803,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "AttributeUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "AttributeUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -834,14 +817,12 @@ public void setMultiplicity(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 = "AttributeUsage") public String getName() { return name; @@ -861,10 +842,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -887,10 +868,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -913,10 +894,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -939,10 +920,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -965,10 +946,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -991,10 +972,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1017,10 +998,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1043,10 +1024,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1069,10 +1050,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1095,10 +1076,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1121,10 +1102,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1277,10 +1258,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1303,10 +1284,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1329,10 +1310,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1355,10 +1336,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1381,10 +1362,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1407,10 +1388,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1433,10 +1414,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1459,10 +1440,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1485,10 +1466,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1511,10 +1492,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1537,10 +1518,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1563,10 +1544,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1589,8 +1570,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "AttributeUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "AttributeUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1610,10 +1591,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1636,10 +1617,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1662,10 +1643,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1688,10 +1669,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1714,10 +1695,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1740,10 +1721,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1766,10 +1747,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1792,10 +1773,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1818,10 +1799,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1844,10 +1825,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1868,10 +1849,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1894,10 +1875,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1920,10 +1901,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1946,10 +1927,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1972,10 +1953,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1998,8 +1979,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "AttributeUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "AttributeUsage") public Element getOwner() { return owner; } @@ -2019,8 +2000,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "AttributeUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "AttributeUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2038,8 +2019,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "AttributeUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "AttributeUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2053,19 +2034,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "AttributeUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "AttributeUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2078,8 +2059,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "AttributeUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "AttributeUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2097,8 +2078,8 @@ 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 = "AttributeUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "AttributeUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2118,8 +2099,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "AttributeUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "AttributeUsage") public Type getOwningType() { return owningType; } @@ -2139,8 +2120,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "AttributeUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "AttributeUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2173,6 +2154,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "AttributeUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2180,10 +2179,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2206,10 +2205,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2232,10 +2231,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2258,10 +2257,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2284,10 +2283,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "AttributeUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/BehaviorImpl.java b/app/org/omg/sysml/metamodel/impl/BehaviorImpl.java index 0b351838..2ba59d86 100644 --- a/app/org/omg/sysml/metamodel/impl/BehaviorImpl.java +++ b/app/org/omg/sysml/metamodel/impl/BehaviorImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Behavior") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class BehaviorImpl extends SysMLTypeImpl implements Behavior { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Behavior_aliasId", - joinColumns = @JoinColumn(name = "BehaviorId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Behavior_aliasIds", + joinColumns = @JoinColumn(name = "Behavior_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Behavior") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Behavior") - 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 = "Behavior") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Behavior") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Behavior") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "Behavior") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Behavior") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Behavior") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Behavior") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Behavior") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Behavior") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Behavior") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Behavior") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Behavior") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "Behavior") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Behavior") public Relationship getOwningRelationship() { return owningRelationship; } @@ -967,10 +948,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1006,6 +987,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Behavior") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1013,10 +1012,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1039,10 +1038,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Behavior_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl.java b/app/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl.java index 11f2014d..8895a491 100644 --- a/app/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "BindingConnectorAsUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class BindingConnectorAsUsageImpl extends SysMLTypeImpl implements BindingConnectorAsUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "BindingConnectorAsUsage_aliasId", - joinColumns = @JoinColumn(name = "BindingConnectorAsUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "BindingConnectorAsUsage_aliasIds", + joinColumns = @JoinColumn(name = "BindingConnectorAsUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "BindingConnectorAsUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "BindingConnectorAsUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "BindingConnectorAsUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "BindingConnectorAsUsage") - 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 = "BindingConnectorAsUsage") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -530,10 +513,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -556,10 +539,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -812,10 +795,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -838,10 +821,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -864,8 +847,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "BindingConnectorAsUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "BindingConnectorAsUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -878,14 +861,12 @@ public void setMultiplicity(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 = "BindingConnectorAsUsage") public String getName() { return name; @@ -905,10 +886,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -931,10 +912,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -957,10 +938,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1165,10 +1146,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1347,10 +1328,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1373,10 +1354,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1399,10 +1380,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1425,10 +1406,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1451,10 +1432,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1477,10 +1458,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1503,10 +1484,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1529,10 +1510,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1555,10 +1536,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1581,10 +1562,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1607,10 +1588,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1633,8 +1614,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "BindingConnectorAsUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "BindingConnectorAsUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1654,10 +1635,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1680,10 +1661,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1706,10 +1687,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1732,10 +1713,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1758,10 +1739,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1784,10 +1765,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1810,10 +1791,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1836,10 +1817,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1862,10 +1843,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1888,10 +1869,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1912,10 +1893,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1936,10 +1917,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1962,10 +1943,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1988,10 +1969,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2014,10 +1995,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2040,10 +2021,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2066,8 +2047,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "BindingConnectorAsUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "BindingConnectorAsUsage") public Element getOwner() { return owner; } @@ -2087,8 +2068,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "BindingConnectorAsUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "BindingConnectorAsUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2106,8 +2087,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "BindingConnectorAsUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "BindingConnectorAsUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2121,19 +2102,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "BindingConnectorAsUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "BindingConnectorAsUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2146,8 +2127,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "BindingConnectorAsUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "BindingConnectorAsUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2165,8 +2146,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "BindingConnectorAsUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "BindingConnectorAsUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2184,8 +2165,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "BindingConnectorAsUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "BindingConnectorAsUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2205,8 +2186,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "BindingConnectorAsUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "BindingConnectorAsUsage") public Type getOwningType() { return owningType; } @@ -2226,8 +2207,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "BindingConnectorAsUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "BindingConnectorAsUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2267,10 +2248,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2293,10 +2274,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2312,15 +2293,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "BindingConnectorAsUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2343,8 +2342,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "BindingConnectorAsUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "BindingConnectorAsUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2362,10 +2361,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2466,10 +2465,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2492,10 +2491,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2518,10 +2517,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnectorAsUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/BindingConnectorImpl.java b/app/org/omg/sysml/metamodel/impl/BindingConnectorImpl.java index ce28be1f..ca49c45e 100644 --- a/app/org/omg/sysml/metamodel/impl/BindingConnectorImpl.java +++ b/app/org/omg/sysml/metamodel/impl/BindingConnectorImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "BindingConnector") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class BindingConnectorImpl extends SysMLTypeImpl implements BindingConnector { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "BindingConnector_aliasId", - joinColumns = @JoinColumn(name = "BindingConnectorId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "BindingConnector_aliasIds", + joinColumns = @JoinColumn(name = "BindingConnector_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "BindingConnector") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "BindingConnector") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "BindingConnector") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "BindingConnector") - 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 = "BindingConnector") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -726,10 +709,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -752,10 +735,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -778,8 +761,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "BindingConnector") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "BindingConnector") public Multiplicity getMultiplicity() { return multiplicity; } @@ -792,14 +775,12 @@ public void setMultiplicity(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 = "BindingConnector") public String getName() { return name; @@ -819,10 +800,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -845,10 +826,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -871,8 +852,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "BindingConnector") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "BindingConnector") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -892,10 +873,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -918,10 +899,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -944,10 +925,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -970,10 +951,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -996,10 +977,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1022,10 +1003,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1048,10 +1029,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1074,10 +1055,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1100,10 +1081,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1126,10 +1107,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1174,10 +1155,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1200,10 +1181,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1226,10 +1207,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1252,10 +1233,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1278,10 +1259,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1304,8 +1285,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "BindingConnector") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "BindingConnector") public Element getOwner() { return owner; } @@ -1323,8 +1304,8 @@ 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 = "BindingConnector") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "BindingConnector") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1338,19 +1319,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "BindingConnector") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "BindingConnector") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1363,8 +1344,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "BindingConnector") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "BindingConnector") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1382,8 +1363,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "BindingConnector") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "BindingConnector") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1401,8 +1382,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "BindingConnector") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "BindingConnector") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1422,8 +1403,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "BindingConnector") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "BindingConnector") public Type getOwningType() { return owningType; } @@ -1463,10 +1444,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1489,10 +1470,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -1508,15 +1489,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "BindingConnector") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1539,8 +1538,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "BindingConnector") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "BindingConnector") public Feature getSourceFeature() { return sourceFeature; } @@ -1558,10 +1557,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1584,10 +1583,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -1610,10 +1609,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1636,10 +1635,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BindingConnector_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/BooleanExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/BooleanExpressionImpl.java index 342f21af..4e5420d1 100644 --- a/app/org/omg/sysml/metamodel/impl/BooleanExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/BooleanExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "BooleanExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class BooleanExpressionImpl extends SysMLTypeImpl implements BooleanExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "BooleanExpression_aliasId", - joinColumns = @JoinColumn(name = "BooleanExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "BooleanExpression_aliasIds", + joinColumns = @JoinColumn(name = "BooleanExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "BooleanExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "BooleanExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "BooleanExpression") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "BooleanExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "BooleanExpression") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "BooleanExpression") - 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 = "BooleanExpression") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "BooleanExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "BooleanExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "BooleanExpression") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "BooleanExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "BooleanExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "BooleanExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "BooleanExpression") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "BooleanExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "BooleanExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "BooleanExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "BooleanExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "BooleanExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "BooleanExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "BooleanExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "BooleanExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "BooleanExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "BooleanExpression") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1423,8 +1404,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "BooleanExpression") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "BooleanExpression") public Predicate getPredicate() { return predicate; } @@ -1464,8 +1445,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "BooleanExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "BooleanExpression") public Feature getResult() { return result; } @@ -1478,6 +1459,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "BooleanExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1485,10 +1484,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1511,10 +1510,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "BooleanExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl.java index 8b2eacdc..3083a50c 100644 --- a/app/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class CalculationDefinitionImpl extends SysMLTypeImpl implements Calculat @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setAction(List action) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "CalculationDefinition_aliasId", - joinColumns = @JoinColumn(name = "CalculationDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "CalculationDefinition_aliasIds", + joinColumns = @JoinColumn(name = "CalculationDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_calculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getCalculation() { if (calculation == null) { calculation = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setCalculation(List calculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -242,6 +243,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "CalculationDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -249,10 +266,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -346,40 +363,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "CalculationDefinition") - 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 = "CalculationDefinition") - 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; @@ -387,10 +370,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -591,8 +574,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "CalculationDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "CalculationDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -612,10 +595,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -638,10 +621,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -664,8 +647,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "CalculationDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "CalculationDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -678,14 +661,12 @@ public void setMultiplicity(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 = "CalculationDefinition") public String getName() { return name; @@ -705,10 +686,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -731,10 +712,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -757,10 +738,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -783,10 +764,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -887,10 +868,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -913,10 +894,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -939,8 +920,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "CalculationDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "CalculationDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -960,10 +941,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -986,10 +967,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1426,10 +1407,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1452,10 +1433,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1478,10 +1459,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1504,10 +1485,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1530,10 +1511,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1556,10 +1537,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1582,10 +1563,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1608,10 +1589,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1634,10 +1615,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1660,10 +1641,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1686,10 +1667,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1712,10 +1693,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1738,8 +1719,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "CalculationDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "CalculationDefinition") public Element getOwner() { return owner; } @@ -1753,19 +1734,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "CalculationDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "CalculationDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1778,8 +1759,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "CalculationDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "CalculationDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1797,8 +1778,8 @@ 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 = "CalculationDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "CalculationDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1818,10 +1799,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1864,8 +1845,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "CalculationDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "CalculationDefinition") public Feature getResult() { return result; } @@ -1878,6 +1859,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "CalculationDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1885,10 +1884,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1911,10 +1910,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1937,10 +1936,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1963,10 +1962,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1989,10 +1988,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/CalculationUsageImpl.java b/app/org/omg/sysml/metamodel/impl/CalculationUsageImpl.java index bcc2f044..b1f9cb7b 100644 --- a/app/org/omg/sysml/metamodel/impl/CalculationUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CalculationUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class CalculationUsageImpl extends SysMLTypeImpl implements CalculationUs @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "CalculationUsage_aliasId", - joinColumns = @JoinColumn(name = "CalculationUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "CalculationUsage_aliasIds", + joinColumns = @JoinColumn(name = "CalculationUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,8 +152,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "calculationDefinitionId", table = "CalculationUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "calculationDefinition_id", table = "CalculationUsage") public Function getCalculationDefinition() { return calculationDefinition; } @@ -172,10 +173,10 @@ public void setCalculationDefinition(Function calculationDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -198,10 +199,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -224,10 +225,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -250,10 +251,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -294,10 +295,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -333,6 +334,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "CalculationUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -340,10 +357,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "CalculationUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "CalculationUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,10 +404,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -465,8 +482,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "CalculationUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "CalculationUsage") public Function getFunction() { return function; } @@ -479,40 +496,6 @@ public void setFunction(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 = "CalculationUsage") - 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 = "CalculationUsage") - 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; @@ -520,10 +503,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -546,8 +529,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "CalculationUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "CalculationUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -567,10 +550,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -593,10 +576,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -619,10 +602,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -893,10 +876,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -919,10 +902,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -945,8 +928,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "CalculationUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "CalculationUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -959,14 +942,12 @@ public void setMultiplicity(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 = "CalculationUsage") public String getName() { return name; @@ -986,10 +967,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1454,10 +1435,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1480,10 +1461,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1506,10 +1487,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1532,10 +1513,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1558,10 +1539,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1584,10 +1565,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1610,10 +1591,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1636,10 +1617,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1662,10 +1643,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1688,10 +1669,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1714,10 +1695,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1740,8 +1721,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "CalculationUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "CalculationUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1761,10 +1742,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1787,10 +1768,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1813,10 +1794,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1839,10 +1820,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1865,10 +1846,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1891,10 +1872,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1917,10 +1898,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1943,10 +1924,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1969,10 +1950,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1995,10 +1976,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2019,10 +2000,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2045,10 +2026,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2071,10 +2052,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2097,10 +2078,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2123,10 +2104,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2149,8 +2130,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "CalculationUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "CalculationUsage") public Element getOwner() { return owner; } @@ -2170,8 +2151,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "CalculationUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "CalculationUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2189,8 +2170,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "CalculationUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "CalculationUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2204,19 +2185,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "CalculationUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "CalculationUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2229,8 +2210,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "CalculationUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "CalculationUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2248,8 +2229,8 @@ 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 = "CalculationUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "CalculationUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2269,8 +2250,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "CalculationUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "CalculationUsage") public Type getOwningType() { return owningType; } @@ -2290,8 +2271,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "CalculationUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "CalculationUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2311,10 +2292,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2355,8 +2336,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "CalculationUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "CalculationUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2396,8 +2377,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "CalculationUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "CalculationUsage") public Feature getResult() { return result; } @@ -2410,6 +2391,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "CalculationUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2417,10 +2416,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2443,10 +2442,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2469,10 +2468,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2495,10 +2494,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2521,10 +2520,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CalculationUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/CaseDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/CaseDefinitionImpl.java index c8639ecf..4c63a661 100644 --- a/app/org/omg/sysml/metamodel/impl/CaseDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CaseDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class CaseDefinitionImpl extends SysMLTypeImpl implements CaseDefinition @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setAction(List action) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "CaseDefinition_aliasId", - joinColumns = @JoinColumn(name = "CaseDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "CaseDefinition_aliasIds", + joinColumns = @JoinColumn(name = "CaseDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_calculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getCalculation() { if (calculation == null) { calculation = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setCalculation(List calculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -268,6 +269,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "CaseDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -275,10 +292,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -372,40 +389,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "CaseDefinition") - 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 = "CaseDefinition") - 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; @@ -413,10 +396,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -617,8 +600,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "CaseDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "CaseDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -638,10 +621,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -664,10 +647,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -690,8 +673,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "CaseDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "CaseDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -704,14 +687,12 @@ public void setMultiplicity(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 = "CaseDefinition") public String getName() { return name; @@ -731,8 +712,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "CaseDefinition") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "CaseDefinition") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -752,10 +733,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -778,10 +759,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -804,10 +785,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -830,10 +811,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -856,10 +837,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -882,10 +863,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -908,10 +889,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -934,10 +915,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -960,10 +941,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -986,8 +967,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "CaseDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "CaseDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1007,10 +988,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1033,10 +1014,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1059,10 +1040,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1473,10 +1454,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1499,10 +1480,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1525,10 +1506,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1551,10 +1532,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1577,10 +1558,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1603,10 +1584,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1629,10 +1610,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1655,10 +1636,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1681,10 +1662,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1707,10 +1688,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1733,10 +1714,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1759,10 +1740,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1785,8 +1766,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "CaseDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "CaseDefinition") public Element getOwner() { return owner; } @@ -1800,19 +1781,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "CaseDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "CaseDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1825,8 +1806,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "CaseDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "CaseDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1844,8 +1825,8 @@ 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 = "CaseDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "CaseDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1865,10 +1846,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1911,8 +1892,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "CaseDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "CaseDefinition") public Feature getResult() { return result; } @@ -1925,6 +1906,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "CaseDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1932,10 +1931,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1958,8 +1957,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "CaseDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "CaseDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -1979,10 +1978,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2005,10 +2004,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2031,10 +2030,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2057,10 +2056,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/CaseUsageImpl.java b/app/org/omg/sysml/metamodel/impl/CaseUsageImpl.java index 44e79ca0..7f3eb198 100644 --- a/app/org/omg/sysml/metamodel/impl/CaseUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CaseUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class CaseUsageImpl extends SysMLTypeImpl implements CaseUsage { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setActionDefinition(List actionDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "CaseUsage_aliasId", - joinColumns = @JoinColumn(name = "CaseUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "CaseUsage_aliasIds", + joinColumns = @JoinColumn(name = "CaseUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,8 +178,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "calculationDefinitionId", table = "CaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "calculationDefinition_id", table = "CaseUsage") public Function getCalculationDefinition() { return calculationDefinition; } @@ -198,8 +199,8 @@ public void setCalculationDefinition(Function calculationDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "caseDefinitionId", table = "CaseUsage") + @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "caseDefinition_id", table = "CaseUsage") public CaseDefinition getCaseDefinition() { return caseDefinition; } @@ -219,10 +220,10 @@ public void setCaseDefinition(CaseDefinition caseDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -245,10 +246,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -297,10 +298,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -341,10 +342,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -380,6 +381,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "CaseUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -387,10 +404,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -413,8 +430,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "CaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "CaseUsage") public Type getEndOwningType() { return endOwningType; } @@ -434,10 +451,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -460,10 +477,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -486,10 +503,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -512,8 +529,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "CaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "CaseUsage") public Function getFunction() { return function; } @@ -526,40 +543,6 @@ public void setFunction(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 = "CaseUsage") - 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 = "CaseUsage") - 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; @@ -567,10 +550,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -593,8 +576,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "CaseUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "CaseUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -614,10 +597,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -640,10 +623,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -666,10 +649,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -940,10 +923,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -966,10 +949,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -992,8 +975,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "CaseUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "CaseUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1006,14 +989,12 @@ public void setMultiplicity(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 = "CaseUsage") public String getName() { return name; @@ -1033,10 +1014,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1059,10 +1040,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1605,10 +1586,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1631,10 +1612,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1657,10 +1638,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1683,10 +1664,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1709,8 +1690,8 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "CaseUsage") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "CaseUsage") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -1730,10 +1711,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1756,10 +1737,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1782,10 +1763,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1808,8 +1789,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "CaseUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "CaseUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1829,10 +1810,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1855,10 +1836,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1881,10 +1862,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1907,10 +1888,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2087,10 +2068,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2113,10 +2094,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2139,10 +2120,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2165,10 +2146,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2191,10 +2172,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2217,8 +2198,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "CaseUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "CaseUsage") public Element getOwner() { return owner; } @@ -2238,8 +2219,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "CaseUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "CaseUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2257,8 +2238,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "CaseUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "CaseUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2272,19 +2253,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "CaseUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "CaseUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2297,8 +2278,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "CaseUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "CaseUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2316,8 +2297,8 @@ 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 = "CaseUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "CaseUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2337,8 +2318,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "CaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "CaseUsage") public Type getOwningType() { return owningType; } @@ -2358,8 +2339,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "CaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "CaseUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2379,10 +2360,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2423,8 +2404,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "CaseUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "CaseUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2464,8 +2445,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "CaseUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "CaseUsage") public Feature getResult() { return result; } @@ -2478,6 +2459,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "CaseUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("subjectParameter") private Usage subjectParameter; @@ -2485,8 +2484,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "CaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "CaseUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2506,10 +2505,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2532,10 +2531,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2558,10 +2557,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2584,10 +2583,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2610,10 +2609,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CaseUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ClassImpl.java b/app/org/omg/sysml/metamodel/impl/ClassImpl.java index 188c0828..4f158d5d 100644 --- a/app/org/omg/sysml/metamodel/impl/ClassImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ClassImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Class") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ClassImpl extends SysMLTypeImpl implements Class { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Class_aliasId", - joinColumns = @JoinColumn(name = "ClassId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Class_aliasIds", + joinColumns = @JoinColumn(name = "Class_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Class") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Class") - 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 = "Class") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Class") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Class") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "Class") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Class") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Class") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Class") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Class") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Class") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Class") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Class") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Class") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "Class") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Class") public Relationship getOwningRelationship() { return owningRelationship; } @@ -980,6 +961,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Class") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -987,10 +986,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Class_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ClassifierImpl.java b/app/org/omg/sysml/metamodel/impl/ClassifierImpl.java index 9563fca4..19433e1e 100644 --- a/app/org/omg/sysml/metamodel/impl/ClassifierImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ClassifierImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Classifier") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ClassifierImpl extends SysMLTypeImpl implements Classifier { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Classifier_aliasId", - joinColumns = @JoinColumn(name = "ClassifierId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Classifier_aliasIds", + joinColumns = @JoinColumn(name = "Classifier_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Classifier") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Classifier") - 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 = "Classifier") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Classifier") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Classifier") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "Classifier") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Classifier") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Classifier") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Classifier") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Classifier") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Classifier") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Classifier") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Classifier") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Classifier") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "Classifier") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Classifier") public Relationship getOwningRelationship() { return owningRelationship; } @@ -980,6 +961,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Classifier") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -987,10 +986,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Classifier_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java index 57c3cbfe..8c58da13 100644 --- a/app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CollectExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "CollectExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class CollectExpressionImpl extends SysMLTypeImpl implements CollectExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "CollectExpression_aliasId", - joinColumns = @JoinColumn(name = "CollectExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "CollectExpression_aliasIds", + joinColumns = @JoinColumn(name = "CollectExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_argument", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getArgument() { if (argument == null) { argument = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setArgument(List argument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "CollectExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "CollectExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "CollectExpression") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "CollectExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "CollectExpression") public Function getFunction() { return function; } @@ -406,40 +423,6 @@ public void setFunction(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 = "CollectExpression") - 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 = "CollectExpression") - 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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -775,10 +758,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -801,8 +784,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "CollectExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "CollectExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -815,14 +798,12 @@ public void setMultiplicity(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 = "CollectExpression") public String getName() { return name; @@ -842,10 +823,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_operand", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOperand() { if (operand == null) { operand = new ArrayList<>(); @@ -886,10 +867,10 @@ public void setOperator(String operator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -912,10 +893,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -938,8 +919,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "CollectExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "CollectExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -959,10 +940,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -985,10 +966,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1011,10 +992,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1037,10 +1018,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1063,10 +1044,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1089,10 +1070,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1115,10 +1096,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1141,10 +1122,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1167,10 +1148,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1193,10 +1174,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1347,8 +1328,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "CollectExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "CollectExpression") public Element getOwner() { return owner; } @@ -1366,8 +1347,8 @@ 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 = "CollectExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "CollectExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1381,19 +1362,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "CollectExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "CollectExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1406,8 +1387,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "CollectExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "CollectExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1425,8 +1406,8 @@ 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 = "CollectExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "CollectExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1446,8 +1427,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "CollectExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "CollectExpression") public Type getOwningType() { return owningType; } @@ -1467,10 +1448,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1513,8 +1494,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "CollectExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "CollectExpression") public Feature getResult() { return result; } @@ -1527,6 +1508,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "CollectExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1534,10 +1533,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1560,10 +1559,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "CollectExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/CommentImpl.java b/app/org/omg/sysml/metamodel/impl/CommentImpl.java index d313c887..7bc275db 100644 --- a/app/org/omg/sysml/metamodel/impl/CommentImpl.java +++ b/app/org/omg/sysml/metamodel/impl/CommentImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Comment") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class CommentImpl extends SysMLTypeImpl implements Comment { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Comment_aliasId", - joinColumns = @JoinColumn(name = "CommentId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Comment_aliasIds", + joinColumns = @JoinColumn(name = "Comment_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_annotatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotatedElement() { if (annotatedElement == null) { annotatedElement = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setAnnotatedElement(List annotatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_annotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotation() { if (annotation == null) { annotation = new ArrayList<>(); @@ -167,10 +168,10 @@ public void setBody(String body) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -206,36 +207,18 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Comment") - 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 = "Comment") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Comment") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -258,14 +241,12 @@ public void setLocale(String locale) { - // @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 = "Comment") public String getName() { return name; @@ -285,10 +266,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -311,10 +292,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -335,10 +316,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -361,8 +342,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Comment") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Comment") public Element getOwner() { return owner; } @@ -376,19 +357,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Comment") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Comment") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -401,8 +382,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Comment") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Comment") public Namespace getOwningNamespace() { return owningNamespace; } @@ -420,8 +401,8 @@ 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 = "Comment") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Comment") public Relationship getOwningRelationship() { return owningRelationship; } @@ -454,6 +435,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Comment") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -461,10 +460,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Comment_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl.java index d646c723..a10024db 100644 --- a/app/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ConcernDefinitionImpl extends SysMLTypeImpl implements ConcernDefin @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConcernDefinition_aliasId", - joinColumns = @JoinColumn(name = "ConcernDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConcernDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ConcernDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -242,6 +243,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConcernDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -249,10 +266,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -372,40 +389,6 @@ public void setFramedConcern(List framedConcern) { - // @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 = "ConcernDefinition") - 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 = "ConcernDefinition") - 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; @@ -413,10 +396,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -617,8 +600,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ConcernDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ConcernDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -638,10 +621,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -664,10 +647,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -690,8 +673,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConcernDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConcernDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -704,14 +687,12 @@ public void setMultiplicity(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 = "ConcernDefinition") public String getName() { return name; @@ -731,10 +712,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -757,10 +738,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -783,10 +764,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -887,10 +868,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -913,10 +894,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -939,10 +920,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -965,8 +946,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConcernDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConcernDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -986,10 +967,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1452,10 +1433,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1478,10 +1459,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1504,10 +1485,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1530,10 +1511,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1556,10 +1537,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1582,10 +1563,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1608,10 +1589,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1634,10 +1615,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1660,10 +1641,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1686,10 +1667,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1712,10 +1693,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1738,10 +1719,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1764,8 +1745,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConcernDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConcernDefinition") public Element getOwner() { return owner; } @@ -1779,19 +1760,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConcernDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConcernDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1804,8 +1785,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConcernDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConcernDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1823,8 +1804,8 @@ 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 = "ConcernDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConcernDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1844,10 +1825,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1908,10 +1889,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -1934,8 +1915,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "ConcernDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "ConcernDefinition") public Feature getResult() { return result; } @@ -1948,6 +1929,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConcernDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -1955,10 +1954,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -1981,10 +1980,10 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -2007,8 +2006,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "ConcernDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "ConcernDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -2031,7 +2030,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "ConcernDefinition_text", - joinColumns = @JoinColumn(name = "ConcernDefinitionId")) + joinColumns = @JoinColumn(name = "ConcernDefinition_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2053,10 +2052,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2079,10 +2078,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2105,10 +2104,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2131,10 +2130,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConcernUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ConcernUsageImpl.java index 675444c0..9a01d3a4 100644 --- a/app/org/omg/sysml/metamodel/impl/ConcernUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConcernUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ConcernUsageImpl extends SysMLTypeImpl implements ConcernUsage { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConcernUsage_aliasId", - joinColumns = @JoinColumn(name = "ConcernUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConcernUsage_aliasIds", + joinColumns = @JoinColumn(name = "ConcernUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -203,8 +204,8 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConcernDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "concernDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "concernDefinitionId", table = "ConcernUsage") + @Any(metaDef = "ConcernDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "concernDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "concernDefinition_id", table = "ConcernUsage") public ConcernDefinition getConcernDefinition() { return concernDefinition; } @@ -224,8 +225,8 @@ public void setConcernDefinition(ConcernDefinition concernDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "constraintDefinitionId", table = "ConcernUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "constraintDefinition_id", table = "ConcernUsage") public Predicate getConstraintDefinition() { return constraintDefinition; } @@ -245,10 +246,10 @@ public void setConstraintDefinition(Predicate constraintDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -297,10 +298,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -341,10 +342,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -380,6 +381,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConcernUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -387,10 +404,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -413,8 +430,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ConcernUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ConcernUsage") public Type getEndOwningType() { return endOwningType; } @@ -434,10 +451,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -460,10 +477,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -486,10 +503,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -512,10 +529,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -538,8 +555,8 @@ public void setFramedConcern(List framedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "ConcernUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "ConcernUsage") public Function getFunction() { return function; } @@ -552,40 +569,6 @@ public void setFunction(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 = "ConcernUsage") - 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 = "ConcernUsage") - 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; @@ -593,10 +576,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -619,8 +602,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ConcernUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ConcernUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -640,10 +623,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -666,10 +649,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -692,10 +675,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -966,10 +949,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -992,10 +975,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1018,8 +1001,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConcernUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConcernUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1032,14 +1015,12 @@ public void setMultiplicity(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 = "ConcernUsage") public String getName() { return name; @@ -1059,10 +1040,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1605,10 +1586,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1631,10 +1612,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1657,10 +1638,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1683,10 +1664,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1709,10 +1690,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1735,10 +1716,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1761,10 +1742,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1787,10 +1768,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1813,8 +1794,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConcernUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConcernUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1834,10 +1815,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1860,10 +1841,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1886,10 +1867,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1912,10 +1893,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1938,10 +1919,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1964,10 +1945,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1990,10 +1971,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2016,10 +1997,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2042,10 +2023,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2068,10 +2049,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2092,10 +2073,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2118,10 +2099,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2144,10 +2125,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2170,10 +2151,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2196,10 +2177,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2222,8 +2203,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConcernUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConcernUsage") public Element getOwner() { return owner; } @@ -2243,8 +2224,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ConcernUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ConcernUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2262,8 +2243,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ConcernUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ConcernUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2277,19 +2258,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConcernUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConcernUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2302,8 +2283,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConcernUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConcernUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2321,8 +2302,8 @@ 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 = "ConcernUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConcernUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2342,8 +2323,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ConcernUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ConcernUsage") public Type getOwningType() { return owningType; } @@ -2363,8 +2344,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ConcernUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ConcernUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2384,10 +2365,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2428,8 +2409,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ConcernUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ConcernUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2449,8 +2430,8 @@ public void setPortioningFeature(PortioningFeature portioningFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "ConcernUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "ConcernUsage") public Predicate getPredicate() { return predicate; } @@ -2508,10 +2489,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -2534,8 +2515,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "requirementDefinitionId", table = "ConcernUsage") + @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "requirementDefinition_id", table = "ConcernUsage") public RequirementDefinition getRequirementDefinition() { return requirementDefinition; } @@ -2555,8 +2536,8 @@ public void setRequirementDefinition(RequirementDefinition requirementDefinition @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "ConcernUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "ConcernUsage") public Feature getResult() { return result; } @@ -2569,6 +2550,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConcernUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -2576,10 +2575,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -2602,8 +2601,8 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "ConcernUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "ConcernUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2626,7 +2625,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "ConcernUsage_text", - joinColumns = @JoinColumn(name = "ConcernUsageId")) + joinColumns = @JoinColumn(name = "ConcernUsage_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2648,10 +2647,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2674,10 +2673,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2700,10 +2699,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2726,10 +2725,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2752,10 +2751,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConcernUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl.java index baadbf5a..ba297dfa 100644 --- a/app/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConjugatedPortDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConjugatedPortDefinitionImpl extends SysMLTypeImpl implements ConjugatedPortDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConjugatedPortDefinition_aliasId", - joinColumns = @JoinColumn(name = "ConjugatedPortDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConjugatedPortDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ConjugatedPortDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,8 +100,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conjugatedPortDefinitionId", table = "ConjugatedPortDefinition") + @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "conjugatedPortDefinition_id", table = "ConjugatedPortDefinition") public ConjugatedPortDefinition getConjugatedPortDefinition() { return conjugatedPortDefinition; } @@ -120,10 +121,10 @@ public void setConjugatedPortDefinition(ConjugatedPortDefinition conjugatedPortD @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -146,10 +147,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -172,10 +173,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -211,6 +212,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConjugatedPortDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -218,10 +235,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -244,10 +261,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -270,10 +287,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -289,40 +306,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "ConjugatedPortDefinition") - 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 = "ConjugatedPortDefinition") - 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; @@ -330,10 +313,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -356,10 +339,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -382,10 +365,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -408,10 +391,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -516,8 +499,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ConjugatedPortDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ConjugatedPortDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -537,10 +520,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -563,10 +546,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -589,8 +572,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConjugatedPortDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConjugatedPortDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -603,14 +586,12 @@ public void setMultiplicity(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 = "ConjugatedPortDefinition") public String getName() { return name; @@ -630,8 +611,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "originalPortDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "originalPortDefinitionId", table = "ConjugatedPortDefinition") + @Any(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "originalPortDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "originalPortDefinition_id", table = "ConjugatedPortDefinition") public PortDefinition getOriginalPortDefinition() { return originalPortDefinition; } @@ -651,10 +632,10 @@ public void setOriginalPortDefinition(PortDefinition originalPortDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -677,10 +658,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -703,10 +684,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -729,10 +710,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -755,10 +736,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -781,10 +762,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -807,10 +788,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -833,10 +814,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -859,10 +840,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -885,8 +866,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConjugatedPortDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConjugatedPortDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -906,10 +887,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -932,10 +913,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -958,10 +939,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -984,10 +965,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1010,10 +991,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1036,10 +1017,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1062,10 +1043,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1088,10 +1069,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1114,10 +1095,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1140,10 +1121,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1166,10 +1147,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1192,10 +1173,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1218,10 +1199,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1244,10 +1225,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1270,10 +1251,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1296,10 +1277,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1322,10 +1303,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1348,8 +1329,8 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedPortConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedPortConjugatorId", table = "ConjugatedPortDefinition") + @Any(metaDef = "PortConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedPortConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedPortConjugator_id", table = "ConjugatedPortDefinition") public PortConjugation getOwnedPortConjugator() { return ownedPortConjugator; } @@ -1369,10 +1350,10 @@ public void setOwnedPortConjugator(PortConjugation ownedPortConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1393,10 +1374,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1419,10 +1400,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1445,10 +1426,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1471,10 +1452,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1497,10 +1478,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1523,10 +1504,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1549,10 +1530,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1575,10 +1556,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1601,10 +1582,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1627,10 +1608,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1653,10 +1634,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1679,10 +1660,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1705,8 +1686,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConjugatedPortDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConjugatedPortDefinition") public Element getOwner() { return owner; } @@ -1720,19 +1701,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConjugatedPortDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConjugatedPortDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1745,8 +1726,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConjugatedPortDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConjugatedPortDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1764,8 +1745,8 @@ 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 = "ConjugatedPortDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConjugatedPortDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1798,6 +1779,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConjugatedPortDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1805,10 +1804,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1831,10 +1830,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1857,10 +1856,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1883,10 +1882,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl.java b/app/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl.java index e8ecba7e..caa14752 100644 --- a/app/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConjugatedPortTyping") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConjugatedPortTypingImpl extends SysMLTypeImpl implements ConjugatedPortTyping { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConjugatedPortTyping_aliasId", - joinColumns = @JoinColumn(name = "ConjugatedPortTypingId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConjugatedPortTyping_aliasIds", + joinColumns = @JoinColumn(name = "ConjugatedPortTyping_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,8 +100,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conjugatedPortDefinitionId", table = "ConjugatedPortTyping") + @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "conjugatedPortDefinition_id", table = "ConjugatedPortTyping") public ConjugatedPortDefinition getConjugatedPortDefinition() { return conjugatedPortDefinition; } @@ -120,10 +121,10 @@ public void setConjugatedPortDefinition(ConjugatedPortDefinition conjugatedPortD @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -159,67 +160,47 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("general") - private Type general; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "generalType"), fetch = FetchType.LAZY) - @JoinColumn(name = "generalId", table = "ConjugatedPortTyping") - public Type getGeneral() { - return general; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) - public void setGeneral(Type general) { - this.general = general; - } - - - - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "ConjugatedPortTyping") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "ConjugatedPortTyping") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("general") + private Type general; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "ConjugatedPortTyping") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "general_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "general_id", table = "ConjugatedPortTyping") + public Type getGeneral() { + return general; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setGeneral(Type general) { + this.general = general; } - // @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 = "ConjugatedPortTyping") public String getName() { return name; @@ -239,10 +220,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -265,10 +246,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -289,10 +270,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -313,10 +294,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -339,8 +320,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConjugatedPortTyping") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConjugatedPortTyping") public Element getOwner() { return owner; } @@ -360,8 +341,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureId", table = "ConjugatedPortTyping") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeature_id", table = "ConjugatedPortTyping") public Feature getOwningFeature() { return owningFeature; } @@ -375,19 +356,19 @@ public void setOwningFeature(Feature owningFeature) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConjugatedPortTyping") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConjugatedPortTyping") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -400,8 +381,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConjugatedPortTyping") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConjugatedPortTyping") public Namespace getOwningNamespace() { return owningNamespace; } @@ -419,8 +400,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ConjugatedPortTyping") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ConjugatedPortTyping") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -438,8 +419,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ConjugatedPortTyping") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConjugatedPortTyping") public Relationship getOwningRelationship() { return owningRelationship; } @@ -459,8 +440,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ConjugatedPortTyping") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ConjugatedPortTyping") public Type getOwningType() { return owningType; } @@ -478,8 +459,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "portDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portDefinitionId", table = "ConjugatedPortTyping") + @Any(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "portDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portDefinition_id", table = "ConjugatedPortTyping") public PortDefinition getPortDefinition() { return portDefinition; } @@ -519,10 +500,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -538,15 +519,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConjugatedPortTyping") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -567,8 +566,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specificType"), fetch = FetchType.LAZY) - @JoinColumn(name = "specificId", table = "ConjugatedPortTyping") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specific_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "specific_id", table = "ConjugatedPortTyping") public Type getSpecific() { return specific; } @@ -586,10 +585,10 @@ public void setSpecific(Type specific) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -612,10 +611,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConjugatedPortTyping_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -636,8 +635,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "typeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "typeId", table = "ConjugatedPortTyping") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "type_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "type_id", table = "ConjugatedPortTyping") public Type getType() { return type; } @@ -655,8 +654,8 @@ public void setType(Type type) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "typedFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "typedFeatureId", table = "ConjugatedPortTyping") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "typedFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "typedFeature_id", table = "ConjugatedPortTyping") public Feature getTypedFeature() { return typedFeature; } diff --git a/app/org/omg/sysml/metamodel/impl/ConjugationImpl.java b/app/org/omg/sysml/metamodel/impl/ConjugationImpl.java index b21dd695..4b4049f7 100644 --- a/app/org/omg/sysml/metamodel/impl/ConjugationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConjugationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Conjugation") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConjugationImpl extends SysMLTypeImpl implements Conjugation { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Conjugation_aliasId", - joinColumns = @JoinColumn(name = "ConjugationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Conjugation_aliasIds", + joinColumns = @JoinColumn(name = "Conjugation_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -97,8 +98,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conjugatedTypeId", table = "Conjugation") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "conjugatedType_id", table = "Conjugation") public Type getConjugatedType() { return conjugatedType; } @@ -118,10 +119,10 @@ public void setConjugatedType(Type conjugatedType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -157,48 +158,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Conjugation") - 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 = "Conjugation") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Conjugation") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "Conjugation") public String getName() { return name; @@ -216,8 +197,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "originalTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "originalTypeId", table = "Conjugation") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "originalType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "originalType_id", table = "Conjugation") public Type getOriginalType() { return originalType; } @@ -237,10 +218,10 @@ public void setOriginalType(Type originalType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -263,10 +244,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -287,10 +268,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -311,10 +292,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -337,8 +318,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Conjugation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Conjugation") public Element getOwner() { return owner; } @@ -352,19 +333,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Conjugation") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Conjugation") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -377,8 +358,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Conjugation") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Conjugation") public Namespace getOwningNamespace() { return owningNamespace; } @@ -396,8 +377,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Conjugation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Conjugation") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -415,8 +396,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Conjugation") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Conjugation") public Relationship getOwningRelationship() { return owningRelationship; } @@ -436,8 +417,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Conjugation") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Conjugation") public Type getOwningType() { return owningType; } @@ -477,10 +458,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -496,15 +477,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Conjugation") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -525,10 +524,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -551,10 +550,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Conjugation_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl.java index 0879ee99..5cbbf03c 100644 --- a/app/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConnectionDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConnectionDefinitionImpl extends SysMLTypeImpl implements ConnectionDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConnectionDefinition_aliasId", - joinColumns = @JoinColumn(name = "ConnectionDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConnectionDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ConnectionDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_associationEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociationEnd() { if (associationEnd == null) { associationEnd = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociationEnd(Collection associationEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_connectionEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionEnd() { if (connectionEnd == null) { connectionEnd = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setConnectionEnd(List connectionEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -242,6 +243,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConnectionDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -249,10 +266,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -320,40 +337,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "ConnectionDefinition") - 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 = "ConnectionDefinition") - 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; @@ -361,10 +344,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -547,8 +530,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ConnectionDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ConnectionDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -568,10 +551,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -594,10 +577,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -620,8 +603,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConnectionDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConnectionDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -634,14 +617,12 @@ public void setMultiplicity(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 = "ConnectionDefinition") public String getName() { return name; @@ -661,10 +642,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -843,10 +824,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -869,10 +850,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -895,8 +876,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConnectionDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConnectionDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -916,10 +897,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1406,10 +1387,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1432,10 +1413,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1458,10 +1439,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1484,10 +1465,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1510,10 +1491,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1536,10 +1517,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1562,10 +1543,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1588,10 +1569,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1614,10 +1595,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1640,10 +1621,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1666,10 +1647,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1692,10 +1673,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1718,8 +1699,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConnectionDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConnectionDefinition") public Element getOwner() { return owner; } @@ -1733,19 +1714,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConnectionDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConnectionDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1758,8 +1739,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConnectionDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConnectionDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1777,8 +1758,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ConnectionDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ConnectionDefinition") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1796,8 +1777,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ConnectionDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConnectionDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1837,10 +1818,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1863,10 +1844,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_relatedType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedType() { if (relatedType == null) { relatedType = new ArrayList<>(); @@ -1882,15 +1863,33 @@ public void setRelatedType(List relatedType) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConnectionDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1913,8 +1912,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceTypeId", table = "ConnectionDefinition") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceType_id", table = "ConnectionDefinition") public Type getSourceType() { return sourceType; } @@ -1932,10 +1931,10 @@ public void setSourceType(Type sourceType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1958,10 +1957,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_targetType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetType() { if (targetType == null) { targetType = new ArrayList<>(); @@ -1984,10 +1983,10 @@ public void setTargetType(Collection targetType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2010,10 +2009,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2036,10 +2035,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2062,10 +2061,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConnectionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ConnectionUsageImpl.java index 3999fd9c..33e07257 100644 --- a/app/org/omg/sysml/metamodel/impl/ConnectionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConnectionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConnectionUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConnectionUsageImpl extends SysMLTypeImpl implements ConnectionUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConnectionUsage_aliasId", - joinColumns = @JoinColumn(name = "ConnectionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConnectionUsage_aliasIds", + joinColumns = @JoinColumn(name = "ConnectionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_connectionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionDefinition() { if (connectionDefinition == null) { connectionDefinition = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectionDefinition(List connectionDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -255,10 +256,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -299,10 +300,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -338,6 +339,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConnectionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -345,10 +362,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -371,8 +388,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ConnectionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ConnectionUsage") public Type getEndOwningType() { return endOwningType; } @@ -392,10 +409,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -463,40 +480,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ConnectionUsage") - 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 = "ConnectionUsage") - 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; @@ -504,10 +487,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -530,8 +513,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ConnectionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ConnectionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -551,10 +534,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -603,10 +586,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -875,10 +858,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -901,10 +884,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -927,10 +910,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -953,8 +936,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConnectionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConnectionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -967,14 +950,12 @@ public void setMultiplicity(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 = "ConnectionUsage") public String getName() { return name; @@ -994,10 +975,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1722,10 +1703,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1748,8 +1729,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConnectionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConnectionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1769,10 +1750,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1795,10 +1776,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1821,10 +1802,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1847,10 +1828,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1873,10 +1854,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1899,10 +1880,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1925,10 +1906,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1951,10 +1932,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2003,10 +1984,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2027,10 +2008,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -2051,10 +2032,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2077,10 +2058,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2103,10 +2084,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2129,10 +2110,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2155,10 +2136,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2181,8 +2162,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConnectionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConnectionUsage") public Element getOwner() { return owner; } @@ -2202,8 +2183,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ConnectionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ConnectionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2221,8 +2202,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ConnectionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ConnectionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2236,19 +2217,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConnectionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConnectionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2261,8 +2242,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConnectionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConnectionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2280,8 +2261,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ConnectionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ConnectionUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2299,8 +2280,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ConnectionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConnectionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2320,8 +2301,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ConnectionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ConnectionUsage") public Type getOwningType() { return owningType; } @@ -2341,8 +2322,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ConnectionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ConnectionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2362,10 +2343,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2406,8 +2387,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ConnectionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ConnectionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2447,10 +2428,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2473,10 +2454,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2492,15 +2473,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConnectionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2523,8 +2522,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "ConnectionUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "ConnectionUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2542,10 +2541,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2568,10 +2567,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2594,10 +2593,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2620,10 +2619,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2646,10 +2645,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2672,10 +2671,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2698,10 +2697,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl.java index 3e5631e1..584219b1 100644 --- a/app/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConnectorAsUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public abstract class ConnectorAsUsageImpl extends SysMLTypeImpl implements ConnectorAsUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConnectorAsUsage_aliasId", - joinColumns = @JoinColumn(name = "ConnectorAsUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConnectorAsUsage_aliasIds", + joinColumns = @JoinColumn(name = "ConnectorAsUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConnectorAsUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ConnectorAsUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ConnectorAsUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ConnectorAsUsage") - 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 = "ConnectorAsUsage") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -530,10 +513,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -556,10 +539,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -812,10 +795,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -838,10 +821,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -864,8 +847,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConnectorAsUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConnectorAsUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -878,14 +861,12 @@ public void setMultiplicity(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 = "ConnectorAsUsage") public String getName() { return name; @@ -905,10 +886,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -931,10 +912,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -957,10 +938,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1165,10 +1146,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1347,10 +1328,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1373,10 +1354,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1399,10 +1380,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1425,10 +1406,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1451,10 +1432,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1477,10 +1458,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1503,10 +1484,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1529,10 +1510,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1555,10 +1536,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1581,10 +1562,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1607,10 +1588,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1633,8 +1614,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConnectorAsUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConnectorAsUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1654,10 +1635,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1680,10 +1661,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1706,10 +1687,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1732,10 +1713,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1758,10 +1739,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1784,10 +1765,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1810,10 +1791,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1836,10 +1817,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1862,10 +1843,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1888,10 +1869,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1912,10 +1893,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1936,10 +1917,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1962,10 +1943,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1988,10 +1969,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2014,10 +1995,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2040,10 +2021,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2066,8 +2047,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConnectorAsUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConnectorAsUsage") public Element getOwner() { return owner; } @@ -2087,8 +2068,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ConnectorAsUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ConnectorAsUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2106,8 +2087,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ConnectorAsUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ConnectorAsUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2121,19 +2102,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConnectorAsUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConnectorAsUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2146,8 +2127,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConnectorAsUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConnectorAsUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2165,8 +2146,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ConnectorAsUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ConnectorAsUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2184,8 +2165,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ConnectorAsUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConnectorAsUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2205,8 +2186,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ConnectorAsUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ConnectorAsUsage") public Type getOwningType() { return owningType; } @@ -2226,8 +2207,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ConnectorAsUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ConnectorAsUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2267,10 +2248,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2293,10 +2274,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2312,15 +2293,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConnectorAsUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2343,8 +2342,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "ConnectorAsUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "ConnectorAsUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2362,10 +2361,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2466,10 +2465,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2492,10 +2491,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2518,10 +2517,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConnectorAsUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConnectorImpl.java b/app/org/omg/sysml/metamodel/impl/ConnectorImpl.java index 9bd894cc..d6848807 100644 --- a/app/org/omg/sysml/metamodel/impl/ConnectorImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConnectorImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Connector") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConnectorImpl extends SysMLTypeImpl implements Connector { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Connector_aliasId", - joinColumns = @JoinColumn(name = "ConnectorId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Connector_aliasIds", + joinColumns = @JoinColumn(name = "Connector_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Connector") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Connector") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Connector") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "Connector") - 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 = "Connector") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -726,10 +709,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -752,10 +735,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -778,8 +761,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Connector") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Connector") public Multiplicity getMultiplicity() { return multiplicity; } @@ -792,14 +775,12 @@ public void setMultiplicity(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 = "Connector") public String getName() { return name; @@ -819,10 +800,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -845,10 +826,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -871,8 +852,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Connector") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Connector") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -892,10 +873,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -918,10 +899,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -944,10 +925,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -970,10 +951,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -996,10 +977,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1022,10 +1003,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1048,10 +1029,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1074,10 +1055,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1100,10 +1081,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1126,10 +1107,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1174,10 +1155,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1200,10 +1181,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1226,10 +1207,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1252,10 +1233,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1278,10 +1259,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1304,8 +1285,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Connector") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Connector") public Element getOwner() { return owner; } @@ -1323,8 +1304,8 @@ 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 = "Connector") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Connector") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1338,19 +1319,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Connector") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Connector") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1363,8 +1344,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Connector") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Connector") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1382,8 +1363,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Connector") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Connector") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1401,8 +1382,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Connector") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Connector") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1422,8 +1403,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Connector") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Connector") public Type getOwningType() { return owningType; } @@ -1463,10 +1444,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1489,10 +1470,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -1508,15 +1489,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Connector") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1539,8 +1538,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "Connector") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "Connector") public Feature getSourceFeature() { return sourceFeature; } @@ -1558,10 +1557,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1584,10 +1583,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -1610,10 +1609,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1636,10 +1635,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Connector_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl.java index 2b848da9..7ec802f5 100644 --- a/app/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConstraintDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConstraintDefinitionImpl extends SysMLTypeImpl implements ConstraintDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConstraintDefinition_aliasId", - joinColumns = @JoinColumn(name = "ConstraintDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConstraintDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ConstraintDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConstraintDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -294,40 +311,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "ConstraintDefinition") - 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 = "ConstraintDefinition") - 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; @@ -335,10 +318,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -539,8 +522,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ConstraintDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ConstraintDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -560,10 +543,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -586,10 +569,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -612,8 +595,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConstraintDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConstraintDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -626,14 +609,12 @@ public void setMultiplicity(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 = "ConstraintDefinition") public String getName() { return name; @@ -653,10 +634,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -679,10 +660,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -705,10 +686,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -731,10 +712,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -757,10 +738,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -783,10 +764,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConstraintDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConstraintDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -908,10 +889,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -934,10 +915,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -960,10 +941,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -986,10 +967,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1374,10 +1355,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1400,10 +1381,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1426,10 +1407,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1452,10 +1433,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1478,10 +1459,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1504,10 +1485,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1530,10 +1511,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1556,10 +1537,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1582,10 +1563,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1608,10 +1589,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1634,10 +1615,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1660,10 +1641,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1686,8 +1667,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConstraintDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConstraintDefinition") public Element getOwner() { return owner; } @@ -1701,19 +1682,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConstraintDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConstraintDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1726,8 +1707,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConstraintDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConstraintDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1745,8 +1726,8 @@ 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 = "ConstraintDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConstraintDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1766,10 +1747,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1812,8 +1793,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "ConstraintDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "ConstraintDefinition") public Feature getResult() { return result; } @@ -1826,6 +1807,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConstraintDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1833,10 +1832,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1859,10 +1858,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1885,10 +1884,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1911,10 +1910,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1937,10 +1936,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ConstraintUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ConstraintUsageImpl.java index c94b481f..a4ad6cad 100644 --- a/app/org/omg/sysml/metamodel/impl/ConstraintUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ConstraintUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ConstraintUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ConstraintUsageImpl extends SysMLTypeImpl implements ConstraintUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ConstraintUsage_aliasId", - joinColumns = @JoinColumn(name = "ConstraintUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ConstraintUsage_aliasIds", + joinColumns = @JoinColumn(name = "ConstraintUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,8 +152,8 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "constraintDefinitionId", table = "ConstraintUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "constraintDefinition_id", table = "ConstraintUsage") public Predicate getConstraintDefinition() { return constraintDefinition; } @@ -172,10 +173,10 @@ public void setConstraintDefinition(Predicate constraintDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -198,10 +199,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -224,10 +225,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -268,10 +269,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -307,6 +308,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ConstraintUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -314,10 +331,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -340,8 +357,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ConstraintUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ConstraintUsage") public Type getEndOwningType() { return endOwningType; } @@ -361,10 +378,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -387,10 +404,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -439,8 +456,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "ConstraintUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "ConstraintUsage") public Function getFunction() { return function; } @@ -453,40 +470,6 @@ public void setFunction(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 = "ConstraintUsage") - 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 = "ConstraintUsage") - 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; @@ -494,10 +477,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -520,8 +503,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ConstraintUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ConstraintUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -541,10 +524,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -567,10 +550,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -593,10 +576,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -867,10 +850,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -893,10 +876,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -919,8 +902,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ConstraintUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ConstraintUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -933,14 +916,12 @@ public void setMultiplicity(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 = "ConstraintUsage") public String getName() { return name; @@ -960,10 +941,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -986,10 +967,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1454,10 +1435,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1480,10 +1461,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1506,10 +1487,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1532,10 +1513,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1558,10 +1539,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1584,10 +1565,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1610,10 +1591,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1636,10 +1617,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1662,10 +1643,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1688,10 +1669,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1714,8 +1695,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ConstraintUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ConstraintUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1735,10 +1716,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1761,10 +1742,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1787,10 +1768,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1813,10 +1794,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1839,10 +1820,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1865,10 +1846,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1891,10 +1872,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1917,10 +1898,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1943,10 +1924,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1969,10 +1950,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1993,10 +1974,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2019,10 +2000,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2045,10 +2026,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2071,10 +2052,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2097,10 +2078,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2123,8 +2104,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ConstraintUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ConstraintUsage") public Element getOwner() { return owner; } @@ -2144,8 +2125,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ConstraintUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ConstraintUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2163,8 +2144,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ConstraintUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ConstraintUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2178,19 +2159,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ConstraintUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ConstraintUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2203,8 +2184,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ConstraintUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ConstraintUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2222,8 +2203,8 @@ 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 = "ConstraintUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ConstraintUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2243,8 +2224,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ConstraintUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ConstraintUsage") public Type getOwningType() { return owningType; } @@ -2264,8 +2245,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ConstraintUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ConstraintUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2285,10 +2266,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2329,8 +2310,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ConstraintUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ConstraintUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2350,8 +2331,8 @@ public void setPortioningFeature(PortioningFeature portioningFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "ConstraintUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "ConstraintUsage") public Predicate getPredicate() { return predicate; } @@ -2391,8 +2372,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "ConstraintUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "ConstraintUsage") public Feature getResult() { return result; } @@ -2405,6 +2386,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ConstraintUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2412,10 +2411,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2438,10 +2437,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2464,10 +2463,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2490,10 +2489,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2516,10 +2515,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ConstraintUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ControlNodeImpl.java b/app/org/omg/sysml/metamodel/impl/ControlNodeImpl.java index cda6943a..9ffe41cc 100644 --- a/app/org/omg/sysml/metamodel/impl/ControlNodeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ControlNodeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public abstract class ControlNodeImpl extends SysMLTypeImpl implements ControlNo @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ControlNode_aliasId", - joinColumns = @JoinColumn(name = "ControlNodeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ControlNode_aliasIds", + joinColumns = @JoinColumn(name = "ControlNode_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ControlNode") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ControlNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ControlNode") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ControlNode") - 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 = "ControlNode") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ControlNode") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ControlNode") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ControlNode") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ControlNode") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "ControlNode") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ControlNode") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ControlNode") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ControlNode") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ControlNode") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ControlNode") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ControlNode") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ControlNode") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ControlNode") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ControlNode") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ControlNode") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ControlNode") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ControlNode") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "ControlNode") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ControlNode") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ControlNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ControlNode") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ControlNode") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ControlNode") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ControlNode") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ControlNode") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2329,6 +2310,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ControlNode") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2336,10 +2335,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ControlNode_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/DataTypeImpl.java b/app/org/omg/sysml/metamodel/impl/DataTypeImpl.java index 8c293932..f59c3132 100644 --- a/app/org/omg/sysml/metamodel/impl/DataTypeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/DataTypeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "DataType") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class DataTypeImpl extends SysMLTypeImpl implements DataType { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "DataType_aliasId", - joinColumns = @JoinColumn(name = "DataTypeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "DataType_aliasIds", + joinColumns = @JoinColumn(name = "DataType_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "DataType") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "DataType") - 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 = "DataType") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "DataType") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "DataType") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "DataType") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "DataType") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "DataType") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "DataType") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "DataType") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "DataType") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "DataType") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "DataType") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "DataType") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "DataType") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "DataType") public Relationship getOwningRelationship() { return owningRelationship; } @@ -980,6 +961,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "DataType") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -987,10 +986,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DataType_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/DecisionNodeImpl.java b/app/org/omg/sysml/metamodel/impl/DecisionNodeImpl.java index 9f210e1a..a944023c 100644 --- a/app/org/omg/sysml/metamodel/impl/DecisionNodeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/DecisionNodeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class DecisionNodeImpl extends SysMLTypeImpl implements DecisionNode { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "DecisionNode_aliasId", - joinColumns = @JoinColumn(name = "DecisionNodeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "DecisionNode_aliasIds", + joinColumns = @JoinColumn(name = "DecisionNode_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "DecisionNode") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "DecisionNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "DecisionNode") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "DecisionNode") - 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 = "DecisionNode") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "DecisionNode") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "DecisionNode") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "DecisionNode") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "DecisionNode") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "DecisionNode") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "DecisionNode") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "DecisionNode") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "DecisionNode") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "DecisionNode") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "DecisionNode") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "DecisionNode") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "DecisionNode") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "DecisionNode") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "DecisionNode") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "DecisionNode") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "DecisionNode") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "DecisionNode") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "DecisionNode") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "DecisionNode") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "DecisionNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "DecisionNode") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "DecisionNode") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "DecisionNode") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "DecisionNode") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "DecisionNode") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2329,6 +2310,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "DecisionNode") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2336,10 +2335,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "DecisionNode_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/DefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/DefinitionImpl.java index d21698f7..9dd41e51 100644 --- a/app/org/omg/sysml/metamodel/impl/DefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/DefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Definition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class DefinitionImpl extends SysMLTypeImpl implements Definition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Definition_aliasId", - joinColumns = @JoinColumn(name = "DefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Definition_aliasIds", + joinColumns = @JoinColumn(name = "Definition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Definition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Definition") - 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 = "Definition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -479,10 +462,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -505,10 +488,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -531,8 +514,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Definition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Definition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -545,14 +528,12 @@ public void setMultiplicity(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 = "Definition") public String getName() { return name; @@ -572,10 +553,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -598,10 +579,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -624,10 +605,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -650,10 +631,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -676,10 +657,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -702,10 +683,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -728,10 +709,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -754,10 +735,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -780,10 +761,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -806,8 +787,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Definition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Definition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -827,10 +808,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -853,10 +834,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -879,10 +860,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -905,10 +886,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -931,10 +912,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -957,10 +938,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1165,10 +1146,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1605,8 +1586,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Definition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Definition") public Element getOwner() { return owner; } @@ -1620,19 +1601,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Definition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Definition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1645,8 +1626,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Definition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Definition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1664,8 +1645,8 @@ 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 = "Definition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Definition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1698,6 +1679,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Definition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1705,10 +1704,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1731,10 +1730,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1757,10 +1756,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1783,10 +1782,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Definition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/DependencyImpl.java b/app/org/omg/sysml/metamodel/impl/DependencyImpl.java index 53147323..ae25edf2 100644 --- a/app/org/omg/sysml/metamodel/impl/DependencyImpl.java +++ b/app/org/omg/sysml/metamodel/impl/DependencyImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Dependency") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class DependencyImpl extends SysMLTypeImpl implements Dependency { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Dependency_aliasId", - joinColumns = @JoinColumn(name = "DependencyId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Dependency_aliasIds", + joinColumns = @JoinColumn(name = "Dependency_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -97,10 +98,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_client", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getClient() { if (client == null) { client = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setClient(List client) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -162,48 +163,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Dependency") - 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 = "Dependency") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Dependency") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "Dependency") public String getName() { return name; @@ -223,10 +204,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -249,10 +230,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -273,10 +254,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -297,10 +278,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -323,8 +304,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Dependency") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Dependency") public Element getOwner() { return owner; } @@ -338,19 +319,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Dependency") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Dependency") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -363,8 +344,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Dependency") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Dependency") public Namespace getOwningNamespace() { return owningNamespace; } @@ -382,8 +363,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Dependency") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Dependency") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -401,8 +382,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Dependency") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Dependency") public Relationship getOwningRelationship() { return owningRelationship; } @@ -442,10 +423,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -461,15 +442,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Dependency") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -490,10 +489,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_supplier", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSupplier() { if (supplier == null) { supplier = new ArrayList<>(); @@ -514,10 +513,10 @@ public void setSupplier(List supplier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -540,10 +539,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Dependency_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/DisjoiningImpl.java b/app/org/omg/sysml/metamodel/impl/DisjoiningImpl.java index 22123b37..db0c4ace 100644 --- a/app/org/omg/sysml/metamodel/impl/DisjoiningImpl.java +++ b/app/org/omg/sysml/metamodel/impl/DisjoiningImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Disjoining") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class DisjoiningImpl extends SysMLTypeImpl implements Disjoining { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Disjoining_aliasId", - joinColumns = @JoinColumn(name = "DisjoiningId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Disjoining_aliasIds", + joinColumns = @JoinColumn(name = "Disjoining_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -97,8 +98,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "disjoiningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "disjoiningTypeId", table = "Disjoining") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "disjoiningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "disjoiningType_id", table = "Disjoining") public Type getDisjoiningType() { return disjoiningType; } @@ -118,10 +119,10 @@ public void setDisjoiningType(Type disjoiningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -157,48 +158,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Disjoining") - 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 = "Disjoining") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Disjoining") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "Disjoining") public String getName() { return name; @@ -218,10 +199,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -244,10 +225,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -268,10 +249,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -292,10 +273,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -318,8 +299,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Disjoining") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Disjoining") public Element getOwner() { return owner; } @@ -333,19 +314,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Disjoining") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Disjoining") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -358,8 +339,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Disjoining") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Disjoining") public Namespace getOwningNamespace() { return owningNamespace; } @@ -377,8 +358,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Disjoining") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Disjoining") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -396,8 +377,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Disjoining") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Disjoining") public Relationship getOwningRelationship() { return owningRelationship; } @@ -417,8 +398,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Disjoining") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Disjoining") public Type getOwningType() { return owningType; } @@ -458,10 +439,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -477,15 +458,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Disjoining") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -506,10 +505,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -532,10 +531,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Disjoining_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -556,8 +555,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "typeDisjoinedType"), fetch = FetchType.LAZY) - @JoinColumn(name = "typeDisjoinedId", table = "Disjoining") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "typeDisjoined_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "typeDisjoined_id", table = "Disjoining") public Type getTypeDisjoined() { return typeDisjoined; } diff --git a/app/org/omg/sysml/metamodel/impl/DocumentationImpl.java b/app/org/omg/sysml/metamodel/impl/DocumentationImpl.java index 957d83c4..4df34423 100644 --- a/app/org/omg/sysml/metamodel/impl/DocumentationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/DocumentationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Documentation") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class DocumentationImpl extends SysMLTypeImpl implements Documentation { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Documentation_aliasId", - joinColumns = @JoinColumn(name = "DocumentationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Documentation_aliasIds", + joinColumns = @JoinColumn(name = "Documentation_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_annotatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotatedElement() { if (annotatedElement == null) { annotatedElement = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setAnnotatedElement(List annotatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_annotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotation() { if (annotation == null) { annotation = new ArrayList<>(); @@ -167,10 +168,10 @@ public void setBody(String body) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -193,8 +194,8 @@ public void setDocumentation(List documentation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "documentedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "documentedElementId", table = "Documentation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "documentedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "documentedElement_id", table = "Documentation") public Element getDocumentedElement() { return documentedElement; } @@ -227,36 +228,18 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Documentation") - 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 = "Documentation") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Documentation") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -279,14 +262,12 @@ public void setLocale(String locale) { - // @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 = "Documentation") public String getName() { return name; @@ -306,10 +287,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -332,10 +313,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -356,10 +337,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -382,8 +363,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Documentation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Documentation") public Element getOwner() { return owner; } @@ -397,19 +378,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Documentation") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Documentation") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -422,8 +403,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Documentation") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Documentation") public Namespace getOwningNamespace() { return owningNamespace; } @@ -441,8 +422,8 @@ 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 = "Documentation") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Documentation") public Relationship getOwningRelationship() { return owningRelationship; } @@ -475,6 +456,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Documentation") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -482,10 +481,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Documentation_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl.java index 6c34e087..68675167 100644 --- a/app/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ElementFilterMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ElementFilterMembershipImpl extends SysMLTypeImpl implements ElementFilterMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ElementFilterMembership_aliasId", - joinColumns = @JoinColumn(name = "ElementFilterMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ElementFilterMembership_aliasIds", + joinColumns = @JoinColumn(name = "ElementFilterMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -97,8 +98,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "conditionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conditionId", table = "ElementFilterMembership") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "condition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "condition_id", table = "ElementFilterMembership") public Expression getCondition() { return condition; } @@ -118,10 +119,10 @@ public void setCondition(Expression condition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -137,26 +138,6 @@ public void setDocumentation(List documentation) { - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; - - @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveMemberName", table = "ElementFilterMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; - } - - @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; - } - - - // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("effectiveName") private String effectiveName; @@ -177,55 +158,57 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "ElementFilterMembership") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "ElementFilterMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("memberElement") + private Element memberElement; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "ElementFilterMembership") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ElementFilterMembership") + public Element getMemberElement() { + return memberElement; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setMemberElement(Element memberElement) { + this.memberElement = memberElement; } - // @info.archinnov.achilles.annotations.Column("memberElement") - private Element memberElement; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ElementFilterMembership") - public Element getMemberElement() { - return memberElement; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ElementFilterMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) - public void setMemberElement(Element memberElement) { - this.memberElement = memberElement; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -248,6 +231,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ElementFilterMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -255,8 +256,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ElementFilterMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ElementFilterMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -269,14 +270,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ElementFilterMembership") public String getName() { return name; @@ -296,10 +295,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -322,10 +321,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -346,8 +345,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ElementFilterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ElementFilterMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -360,15 +359,75 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ElementFilterMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ElementFilterMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ElementFilterMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -389,10 +448,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -415,8 +474,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ElementFilterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ElementFilterMembership") public Element getOwner() { return owner; } @@ -430,19 +489,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ElementFilterMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ElementFilterMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -455,8 +514,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ElementFilterMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ElementFilterMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -474,8 +533,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ElementFilterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ElementFilterMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -493,8 +552,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ElementFilterMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ElementFilterMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -534,10 +593,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -553,15 +612,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ElementFilterMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -582,10 +659,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -608,10 +685,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ElementFilterMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ElementImpl.java b/app/org/omg/sysml/metamodel/impl/ElementImpl.java index 23cce9e7..34571c89 100644 --- a/app/org/omg/sysml/metamodel/impl/ElementImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ElementImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Element") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ElementImpl extends SysMLTypeImpl implements Element { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Element_aliasId", - joinColumns = @JoinColumn(name = "ElementId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Element_aliasIds", + joinColumns = @JoinColumn(name = "Element_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Element_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,48 +139,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Element") - 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 = "Element") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Element") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "Element") public String getName() { return name; @@ -199,10 +180,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Element_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -225,10 +206,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Element_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -249,10 +230,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Element_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -275,8 +256,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Element") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Element") public Element getOwner() { return owner; } @@ -290,19 +271,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Element") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Element") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -315,8 +296,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Element") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Element") public Namespace getOwningNamespace() { return owningNamespace; } @@ -334,8 +315,8 @@ 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 = "Element") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Element") public Relationship getOwningRelationship() { return owningRelationship; } @@ -368,6 +349,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Element") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -375,10 +374,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Element_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl.java index c995c197..e2c10a55 100644 --- a/app/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "EndFeatureMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class EndFeatureMembershipImpl extends SysMLTypeImpl implements EndFeatureMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "EndFeatureMembership_aliasId", - joinColumns = @JoinColumn(name = "EndFeatureMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "EndFeatureMembership_aliasIds", + joinColumns = @JoinColumn(name = "EndFeatureMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "EndFeatureMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "EndFeatureMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "EndFeatureMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "EndFeatureMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "EndFeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "EndFeatureMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "EndFeatureMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "EndFeatureMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "EndFeatureMembership") - 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 = "EndFeatureMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "EndFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "EndFeatureMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "EndFeatureMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "EndFeatureMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,6 +250,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "EndFeatureMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -293,8 +275,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "EndFeatureMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "EndFeatureMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -307,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "EndFeatureMembership") public String getName() { return name; @@ -334,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -360,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -384,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "EndFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "EndFeatureMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -398,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "EndFeatureMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "EndFeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "EndFeatureMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -417,15 +417,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "EndFeatureMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "EndFeatureMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -446,10 +486,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -472,8 +512,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "EndFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "EndFeatureMembership") public Element getOwner() { return owner; } @@ -493,8 +533,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "EndFeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "EndFeatureMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -508,19 +548,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "EndFeatureMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "EndFeatureMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -533,8 +573,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "EndFeatureMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "EndFeatureMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -552,8 +592,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "EndFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "EndFeatureMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -571,8 +611,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "EndFeatureMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "EndFeatureMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -592,8 +632,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "EndFeatureMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "EndFeatureMembership") public Type getOwningType() { return owningType; } @@ -633,10 +673,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -652,15 +692,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "EndFeatureMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -681,10 +739,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -707,10 +765,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EndFeatureMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl.java index 27d19a5e..fac82e28 100644 --- a/app/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "EnumerationDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class EnumerationDefinitionImpl extends SysMLTypeImpl implements EnumerationDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "EnumerationDefinition_aliasId", - joinColumns = @JoinColumn(name = "EnumerationDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "EnumerationDefinition_aliasIds", + joinColumns = @JoinColumn(name = "EnumerationDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "EnumerationDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_enumeratedValue", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEnumeratedValue() { if (enumeratedValue == null) { enumeratedValue = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setEnumeratedValue(List enumeratedValue) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -294,40 +311,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "EnumerationDefinition") - 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 = "EnumerationDefinition") - 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; @@ -335,10 +318,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -505,10 +488,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -531,10 +514,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -557,8 +540,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "EnumerationDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "EnumerationDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -571,14 +554,12 @@ public void setMultiplicity(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 = "EnumerationDefinition") public String getName() { return name; @@ -598,10 +579,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -624,10 +605,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -650,10 +631,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -676,10 +657,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -702,10 +683,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -728,10 +709,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -754,10 +735,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -780,10 +761,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -806,10 +787,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -832,8 +813,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "EnumerationDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "EnumerationDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -853,10 +834,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -879,10 +860,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -905,10 +886,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -931,10 +912,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -957,10 +938,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1165,10 +1146,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1605,10 +1586,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1631,8 +1612,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "EnumerationDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "EnumerationDefinition") public Element getOwner() { return owner; } @@ -1646,19 +1627,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "EnumerationDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "EnumerationDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1671,8 +1652,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "EnumerationDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "EnumerationDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1690,8 +1671,8 @@ 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 = "EnumerationDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "EnumerationDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1724,6 +1705,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "EnumerationDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1731,10 +1730,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1757,10 +1756,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1783,10 +1782,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1809,10 +1808,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/EnumerationUsageImpl.java b/app/org/omg/sysml/metamodel/impl/EnumerationUsageImpl.java index 1e5c8a47..d317cffd 100644 --- a/app/org/omg/sysml/metamodel/impl/EnumerationUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/EnumerationUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "EnumerationUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class EnumerationUsageImpl extends SysMLTypeImpl implements EnumerationUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "EnumerationUsage_aliasId", - joinColumns = @JoinColumn(name = "EnumerationUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "EnumerationUsage_aliasIds", + joinColumns = @JoinColumn(name = "EnumerationUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DataTypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DataTypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_attributeDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAttributeDefinition() { if (attributeDefinition == null) { attributeDefinition = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAttributeDefinition(List attributeDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -247,10 +248,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -286,6 +287,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "EnumerationUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -293,10 +310,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -319,8 +336,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "EnumerationUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "EnumerationUsage") public Type getEndOwningType() { return endOwningType; } @@ -340,8 +357,8 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "EnumerationDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "enumerationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "enumerationDefinitionId", table = "EnumerationUsage") + @Any(metaDef = "EnumerationDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "enumerationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "enumerationDefinition_id", table = "EnumerationUsage") public EnumerationDefinition getEnumerationDefinition() { return enumerationDefinition; } @@ -361,10 +378,10 @@ public void setEnumerationDefinition(EnumerationDefinition enumerationDefinition @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -387,10 +404,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -432,40 +449,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "EnumerationUsage") - 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 = "EnumerationUsage") - 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; @@ -473,10 +456,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -789,10 +772,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -815,10 +798,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -841,8 +824,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "EnumerationUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "EnumerationUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -855,14 +838,12 @@ public void setMultiplicity(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 = "EnumerationUsage") public String getName() { return name; @@ -882,10 +863,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -908,10 +889,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -934,10 +915,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -960,10 +941,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -986,10 +967,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1454,10 +1435,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1480,10 +1461,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1506,10 +1487,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1532,10 +1513,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1558,10 +1539,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1584,10 +1565,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1610,8 +1591,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "EnumerationUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "EnumerationUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1631,10 +1612,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1657,10 +1638,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1683,10 +1664,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1709,10 +1690,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1735,10 +1716,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1761,10 +1742,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1787,10 +1768,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1813,10 +1794,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1839,10 +1820,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1865,10 +1846,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1889,10 +1870,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1915,10 +1896,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1941,10 +1922,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1967,10 +1948,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1993,10 +1974,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2019,8 +2000,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "EnumerationUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "EnumerationUsage") public Element getOwner() { return owner; } @@ -2040,8 +2021,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "EnumerationUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "EnumerationUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2059,8 +2040,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "EnumerationUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "EnumerationUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2074,19 +2055,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "EnumerationUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "EnumerationUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2099,8 +2080,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "EnumerationUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "EnumerationUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2118,8 +2099,8 @@ 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 = "EnumerationUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "EnumerationUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2139,8 +2120,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "EnumerationUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "EnumerationUsage") public Type getOwningType() { return owningType; } @@ -2160,8 +2141,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "EnumerationUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "EnumerationUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2194,6 +2175,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "EnumerationUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2201,10 +2200,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2227,10 +2226,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2253,10 +2252,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2279,10 +2278,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2305,10 +2304,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EnumerationUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl.java b/app/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl.java index c46c170a..89c5068b 100644 --- a/app/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "EventOccurrenceUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class EventOccurrenceUsageImpl extends SysMLTypeImpl implements EventOccurrenceUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "EventOccurrenceUsage_aliasId", - joinColumns = @JoinColumn(name = "EventOccurrenceUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "EventOccurrenceUsage_aliasIds", + joinColumns = @JoinColumn(name = "EventOccurrenceUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "EventOccurrenceUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "EventOccurrenceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "EventOccurrenceUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,8 +331,8 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrenceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "eventOccurrenceId", table = "EventOccurrenceUsage") + @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrence_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "eventOccurrence_id", table = "EventOccurrenceUsage") public OccurrenceUsage getEventOccurrence() { return eventOccurrence; } @@ -335,10 +352,10 @@ public void setEventOccurrence(OccurrenceUsage eventOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -361,10 +378,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -387,10 +404,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -406,40 +423,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "EventOccurrenceUsage") - 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 = "EventOccurrenceUsage") - 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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,8 +456,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "EventOccurrenceUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "EventOccurrenceUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -494,10 +477,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -520,10 +503,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -546,10 +529,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -802,10 +785,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -828,10 +811,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -854,8 +837,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "EventOccurrenceUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "EventOccurrenceUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -868,14 +851,12 @@ public void setMultiplicity(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 = "EventOccurrenceUsage") public String getName() { return name; @@ -895,10 +876,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -921,10 +902,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -947,10 +928,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -973,10 +954,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -999,10 +980,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1025,10 +1006,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1051,10 +1032,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1077,10 +1058,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1103,10 +1084,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1129,10 +1110,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1155,10 +1136,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1181,10 +1162,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1207,10 +1188,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1233,10 +1214,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1259,10 +1240,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1285,10 +1266,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1311,10 +1292,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1337,10 +1318,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1363,10 +1344,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1389,10 +1370,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1415,10 +1396,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1441,10 +1422,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1467,10 +1448,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1493,10 +1474,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1519,10 +1500,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1545,10 +1526,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1571,10 +1552,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1597,10 +1578,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1623,10 +1604,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1649,8 +1630,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "EventOccurrenceUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "EventOccurrenceUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1670,10 +1651,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1722,10 +1703,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1774,10 +1755,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1800,10 +1781,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1826,10 +1807,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1852,10 +1833,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1878,10 +1859,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1904,10 +1885,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1928,10 +1909,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1954,10 +1935,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2058,8 +2039,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "EventOccurrenceUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "EventOccurrenceUsage") public Element getOwner() { return owner; } @@ -2079,8 +2060,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "EventOccurrenceUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "EventOccurrenceUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2098,8 +2079,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "EventOccurrenceUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "EventOccurrenceUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2113,19 +2094,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "EventOccurrenceUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "EventOccurrenceUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2138,8 +2119,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "EventOccurrenceUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "EventOccurrenceUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2157,8 +2138,8 @@ 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 = "EventOccurrenceUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "EventOccurrenceUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2178,8 +2159,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "EventOccurrenceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "EventOccurrenceUsage") public Type getOwningType() { return owningType; } @@ -2199,8 +2180,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "EventOccurrenceUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "EventOccurrenceUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2238,8 +2219,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "EventOccurrenceUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "EventOccurrenceUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2272,6 +2253,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "EventOccurrenceUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2279,10 +2278,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2305,10 +2304,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2331,10 +2330,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2357,10 +2356,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2383,10 +2382,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "EventOccurrenceUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl.java index dc103b94..f564483b 100644 --- a/app/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ExhibitStateUsageImpl extends SysMLTypeImpl implements ExhibitState @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ExhibitStateUsage_aliasId", - joinColumns = @JoinColumn(name = "ExhibitStateUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ExhibitStateUsage_aliasIds", + joinColumns = @JoinColumn(name = "ExhibitStateUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,8 +274,8 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "doActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "doActionId", table = "ExhibitStateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "doAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "doAction_id", table = "ExhibitStateUsage") public ActionUsage getDoAction() { return doAction; } @@ -294,10 +295,10 @@ public void setDoAction(ActionUsage doAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -333,6 +334,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ExhibitStateUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -340,10 +357,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ExhibitStateUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ExhibitStateUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,8 +404,8 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "entryActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "entryActionId", table = "ExhibitStateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "entryAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "entryAction_id", table = "ExhibitStateUsage") public ActionUsage getEntryAction() { return entryAction; } @@ -408,8 +425,8 @@ public void setEntryAction(ActionUsage entryAction) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrenceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "eventOccurrenceId", table = "ExhibitStateUsage") + @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrence_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "eventOccurrence_id", table = "ExhibitStateUsage") public OccurrenceUsage getEventOccurrence() { return eventOccurrence; } @@ -429,8 +446,8 @@ public void setEventOccurrence(OccurrenceUsage eventOccurrence) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exhibitedStateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "exhibitedStateId", table = "ExhibitStateUsage") + @Any(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exhibitedState_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "exhibitedState_id", table = "ExhibitStateUsage") public StateUsage getExhibitedState() { return exhibitedState; } @@ -450,8 +467,8 @@ public void setExhibitedState(StateUsage exhibitedState) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exitActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "exitActionId", table = "ExhibitStateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exitAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "exitAction_id", table = "ExhibitStateUsage") public ActionUsage getExitAction() { return exitAction; } @@ -471,10 +488,10 @@ public void setExitAction(ActionUsage exitAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -497,10 +514,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -523,10 +540,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -542,40 +559,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ExhibitStateUsage") - 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 = "ExhibitStateUsage") - 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; @@ -583,10 +566,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -609,8 +592,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ExhibitStateUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ExhibitStateUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -630,10 +613,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -656,10 +639,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -682,10 +665,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -954,10 +937,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -980,10 +963,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1006,8 +989,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ExhibitStateUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ExhibitStateUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1020,14 +1003,12 @@ public void setMultiplicity(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 = "ExhibitStateUsage") public String getName() { return name; @@ -1047,10 +1028,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1073,10 +1054,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1099,10 +1080,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1125,10 +1106,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1151,10 +1132,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1177,10 +1158,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1203,10 +1184,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1229,10 +1210,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1255,10 +1236,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1281,10 +1262,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1307,10 +1288,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1333,10 +1314,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1359,10 +1340,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1385,10 +1366,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1411,10 +1392,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1437,10 +1418,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1463,10 +1444,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1489,10 +1470,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1515,10 +1496,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1541,10 +1522,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1567,10 +1548,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1593,10 +1574,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1619,10 +1600,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1645,10 +1626,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1671,10 +1652,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1697,10 +1678,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1723,10 +1704,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1749,10 +1730,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1775,10 +1756,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1801,8 +1782,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ExhibitStateUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ExhibitStateUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1822,10 +1803,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1848,10 +1829,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1874,10 +1855,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1900,10 +1881,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1926,10 +1907,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1952,10 +1933,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1978,10 +1959,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2004,10 +1985,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2030,10 +2011,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2056,10 +2037,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2080,10 +2061,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2106,10 +2087,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2132,10 +2113,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2158,10 +2139,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2184,10 +2165,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2210,8 +2191,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ExhibitStateUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ExhibitStateUsage") public Element getOwner() { return owner; } @@ -2231,8 +2212,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ExhibitStateUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ExhibitStateUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2250,8 +2231,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ExhibitStateUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ExhibitStateUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2265,19 +2246,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ExhibitStateUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ExhibitStateUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2290,8 +2271,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ExhibitStateUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ExhibitStateUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2309,8 +2290,8 @@ 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 = "ExhibitStateUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ExhibitStateUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2330,8 +2311,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ExhibitStateUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ExhibitStateUsage") public Type getOwningType() { return owningType; } @@ -2351,8 +2332,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ExhibitStateUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ExhibitStateUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2372,10 +2353,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2398,8 +2379,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "performedActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "performedActionId", table = "ExhibitStateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "performedAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "performedAction_id", table = "ExhibitStateUsage") public ActionUsage getPerformedAction() { return performedAction; } @@ -2437,8 +2418,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ExhibitStateUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ExhibitStateUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2471,6 +2452,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ExhibitStateUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stateDefinition") private List stateDefinition; @@ -2478,10 +2477,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_stateDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStateDefinition() { if (stateDefinition == null) { stateDefinition = new ArrayList<>(); @@ -2504,10 +2503,10 @@ public void setStateDefinition(List stateDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2530,10 +2529,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2556,10 +2555,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2582,10 +2581,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2608,10 +2607,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ExhibitStateUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ExposeImpl.java b/app/org/omg/sysml/metamodel/impl/ExposeImpl.java index 8ae9a4e4..e3f97def 100644 --- a/app/org/omg/sysml/metamodel/impl/ExposeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ExposeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Expose") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ExposeImpl extends SysMLTypeImpl implements Expose { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Expose_aliasId", - joinColumns = @JoinColumn(name = "ExposeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Expose_aliasIds", + joinColumns = @JoinColumn(name = "Expose_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,36 +139,18 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Expose") - 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 = "Expose") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Expose") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -179,8 +162,8 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "importOwningNamespaceId", table = "Expose") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "importOwningNamespace_id", table = "Expose") public Namespace getImportOwningNamespace() { return importOwningNamespace; } @@ -216,8 +199,8 @@ public void setImportedMemberName(String importedMemberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importedNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "importedNamespaceId", table = "Expose") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importedNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "importedNamespace_id", table = "Expose") public Namespace getImportedNamespace() { return importedNamespace; } @@ -262,14 +245,12 @@ public void setIsRecursive(Boolean isRecursive) { - // @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 = "Expose") public String getName() { return name; @@ -289,10 +270,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -315,10 +296,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -339,10 +320,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -363,10 +344,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -389,8 +370,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Expose") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Expose") public Element getOwner() { return owner; } @@ -404,19 +385,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Expose") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Expose") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -429,8 +410,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Expose") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Expose") public Namespace getOwningNamespace() { return owningNamespace; } @@ -448,8 +429,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Expose") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Expose") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -467,8 +448,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Expose") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Expose") public Relationship getOwningRelationship() { return owningRelationship; } @@ -508,10 +489,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -527,15 +508,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Expose") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -556,10 +555,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -582,10 +581,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expose_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/ExpressionImpl.java index c51adc1c..f7b9b150 100644 --- a/app/org/omg/sysml/metamodel/impl/ExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Expression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ExpressionImpl extends SysMLTypeImpl implements Expression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Expression_aliasId", - joinColumns = @JoinColumn(name = "ExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Expression_aliasIds", + joinColumns = @JoinColumn(name = "Expression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Expression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Expression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Expression") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "Expression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "Expression") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "Expression") - 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 = "Expression") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Expression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Expression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "Expression") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Expression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Expression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Expression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Expression") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "Expression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Expression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Expression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Expression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Expression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Expression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "Expression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Expression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Expression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Expression") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "Expression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "Expression") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Expression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Expression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java index 1fd0dfe6..c46dd86c 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FeatureChainExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureChainExpressionImpl extends SysMLTypeImpl implements FeatureChainExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @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<>(); + @CollectionTable(name = "FeatureChainExpression_aliasIds", + joinColumns = @JoinColumn(name = "FeatureChainExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_argument", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getArgument() { if (argument == null) { argument = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setArgument(List argument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "FeatureChainExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @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") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "FeatureChainExpression") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setFeaturingType(List featuringType) { @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") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "FeatureChainExpression") public Function getFunction() { return function; } @@ -406,40 +423,6 @@ public void setFunction(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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -775,10 +758,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -801,8 +784,8 @@ public void setMembership(List membership) { @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") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "FeatureChainExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -815,14 +798,12 @@ public void setMultiplicity(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; @@ -842,10 +823,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_operand", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOperand() { if (operand == null) { operand = new ArrayList<>(); @@ -886,10 +867,10 @@ public void setOperator(String operator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -912,10 +893,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -938,8 +919,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @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") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "FeatureChainExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -959,10 +940,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -985,10 +966,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1011,10 +992,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1037,10 +1018,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1063,10 +1044,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1089,10 +1070,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1115,10 +1096,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1141,10 +1122,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1167,10 +1148,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1193,10 +1174,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1347,8 +1328,8 @@ public void setOwnedTyping(List ownedTyping) { @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") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FeatureChainExpression") public Element getOwner() { return owner; } @@ -1366,8 +1347,8 @@ 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 = "FeatureChainExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "FeatureChainExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1381,19 +1362,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership 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() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FeatureChainExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1406,8 +1387,8 @@ public void setOwningMembership(Membership owningMembership) { @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") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FeatureChainExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1425,8 +1406,8 @@ 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 = "FeatureChainExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FeatureChainExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1446,8 +1427,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @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") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "FeatureChainExpression") public Type getOwningType() { return owningType; } @@ -1467,10 +1448,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1513,8 +1494,8 @@ public void setQualifiedName(String qualifiedName) { @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") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "FeatureChainExpression") public Feature getResult() { return result; } @@ -1527,6 +1508,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FeatureChainExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("targetFeature") private Feature targetFeature; @@ -1534,8 +1533,8 @@ public void setResult(Feature result) { @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") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "targetFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "targetFeature_id", table = "FeatureChainExpression") public Feature getTargetFeature() { return targetFeature; } @@ -1555,10 +1554,10 @@ public void setTargetFeature(Feature targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1581,10 +1580,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChainExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FeatureChainingImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureChainingImpl.java index fb00e323..d519ef9a 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureChainingImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureChainingImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FeatureChaining") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureChainingImpl extends SysMLTypeImpl implements FeatureChaining { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FeatureChaining_aliasId", - joinColumns = @JoinColumn(name = "FeatureChainingId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FeatureChaining_aliasIds", + joinColumns = @JoinColumn(name = "FeatureChaining_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -97,8 +98,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "chainingFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "chainingFeatureId", table = "FeatureChaining") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "chainingFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "chainingFeature_id", table = "FeatureChaining") public Feature getChainingFeature() { return chainingFeature; } @@ -118,10 +119,10 @@ public void setChainingFeature(Feature chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -157,6 +158,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "FeatureChaining") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("featureChained") private Feature featureChained; @@ -164,8 +181,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureChainedType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureChainedId", table = "FeatureChaining") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureChained_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureChained_id", table = "FeatureChaining") public Feature getFeatureChained() { return featureChained; } @@ -178,48 +195,12 @@ public void setFeatureChained(Feature featureChained) { - // @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 = "FeatureChaining") - 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 = "FeatureChaining") - 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("name") private String name; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient @javax.persistence.Column(name = "name", table = "FeatureChaining") public String getName() { return name; @@ -239,10 +220,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -265,10 +246,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -289,10 +270,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -313,10 +294,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -339,8 +320,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FeatureChaining") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FeatureChaining") public Element getOwner() { return owner; } @@ -354,19 +335,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FeatureChaining") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FeatureChaining") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -379,8 +360,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FeatureChaining") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FeatureChaining") public Namespace getOwningNamespace() { return owningNamespace; } @@ -398,8 +379,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "FeatureChaining") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "FeatureChaining") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -417,8 +398,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "FeatureChaining") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FeatureChaining") public Relationship getOwningRelationship() { return owningRelationship; } @@ -458,10 +439,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -477,15 +458,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FeatureChaining") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -506,10 +505,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -532,10 +531,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureChaining_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FeatureImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureImpl.java index 33d657fc..1cc78e20 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Feature") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureImpl extends SysMLTypeImpl implements Feature { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Feature_aliasId", - joinColumns = @JoinColumn(name = "FeatureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Feature_aliasIds", + joinColumns = @JoinColumn(name = "Feature_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Feature") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Feature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Feature") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "Feature") - 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 = "Feature") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Feature") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Feature") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "Feature") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Feature") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Feature") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Feature") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Feature") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "Feature") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Feature") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Feature") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Feature") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Feature") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Feature") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "Feature") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Feature") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Feature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Feature") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Feature") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Feature_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FeatureMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureMembershipImpl.java index 7f1760c9..743c6302 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FeatureMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureMembershipImpl extends SysMLTypeImpl implements FeatureMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FeatureMembership_aliasId", - joinColumns = @JoinColumn(name = "FeatureMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FeatureMembership_aliasIds", + joinColumns = @JoinColumn(name = "FeatureMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "FeatureMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "FeatureMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "FeatureMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "FeatureMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "FeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "FeatureMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "FeatureMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "FeatureMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "FeatureMembership") - 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 = "FeatureMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "FeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "FeatureMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "FeatureMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "FeatureMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,6 +250,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "FeatureMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -293,8 +275,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "FeatureMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "FeatureMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -307,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "FeatureMembership") public String getName() { return name; @@ -334,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -360,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -384,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "FeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "FeatureMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -398,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "FeatureMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "FeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "FeatureMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -417,15 +417,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "FeatureMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "FeatureMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -446,10 +486,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -472,8 +512,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FeatureMembership") public Element getOwner() { return owner; } @@ -493,8 +533,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "FeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "FeatureMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -508,19 +548,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FeatureMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FeatureMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -533,8 +573,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FeatureMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FeatureMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -552,8 +592,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "FeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "FeatureMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -571,8 +611,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "FeatureMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FeatureMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -592,8 +632,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "FeatureMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "FeatureMembership") public Type getOwningType() { return owningType; } @@ -633,10 +673,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -652,15 +692,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FeatureMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -681,10 +739,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -707,10 +765,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl.java index 04887049..b9021092 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FeatureReferenceExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureReferenceExpressionImpl extends SysMLTypeImpl implements FeatureReferenceExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FeatureReferenceExpression_aliasId", - joinColumns = @JoinColumn(name = "FeatureReferenceExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FeatureReferenceExpression_aliasIds", + joinColumns = @JoinColumn(name = "FeatureReferenceExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "FeatureReferenceExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "FeatureReferenceExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "FeatureReferenceExpression") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "FeatureReferenceExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "FeatureReferenceExpression") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "FeatureReferenceExpression") - 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 = "FeatureReferenceExpression") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "FeatureReferenceExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "FeatureReferenceExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "FeatureReferenceExpression") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "FeatureReferenceExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "FeatureReferenceExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FeatureReferenceExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FeatureReferenceExpression") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "FeatureReferenceExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "FeatureReferenceExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FeatureReferenceExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FeatureReferenceExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FeatureReferenceExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FeatureReferenceExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "FeatureReferenceExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FeatureReferenceExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "FeatureReferenceExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "FeatureReferenceExpression") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "referentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referentId", table = "FeatureReferenceExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "referent_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referent_id", table = "FeatureReferenceExpression") public Feature getReferent() { return referent; } @@ -1464,8 +1445,8 @@ public void setReferent(Feature referent) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "FeatureReferenceExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "FeatureReferenceExpression") public Feature getResult() { return result; } @@ -1478,6 +1459,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FeatureReferenceExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1485,10 +1484,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1511,10 +1510,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureReferenceExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FeatureTypingImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureTypingImpl.java index 24ebe841..805af3c1 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureTypingImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureTypingImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FeatureTyping") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureTypingImpl extends SysMLTypeImpl implements FeatureTyping { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FeatureTyping_aliasId", - joinColumns = @JoinColumn(name = "FeatureTypingId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FeatureTyping_aliasIds", + joinColumns = @JoinColumn(name = "FeatureTyping_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,67 +139,47 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("general") - private Type general; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "generalType"), fetch = FetchType.LAZY) - @JoinColumn(name = "generalId", table = "FeatureTyping") - public Type getGeneral() { - return general; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) - public void setGeneral(Type general) { - this.general = general; - } - - - - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "FeatureTyping") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "FeatureTyping") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("general") + private Type general; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "FeatureTyping") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "general_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "general_id", table = "FeatureTyping") + public Type getGeneral() { + return general; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setGeneral(Type general) { + this.general = general; } - // @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 = "FeatureTyping") public String getName() { return name; @@ -218,10 +199,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -244,10 +225,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -268,10 +249,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -292,10 +273,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -318,8 +299,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FeatureTyping") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FeatureTyping") public Element getOwner() { return owner; } @@ -339,8 +320,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureId", table = "FeatureTyping") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeature_id", table = "FeatureTyping") public Feature getOwningFeature() { return owningFeature; } @@ -354,19 +335,19 @@ public void setOwningFeature(Feature owningFeature) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FeatureTyping") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FeatureTyping") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -379,8 +360,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FeatureTyping") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FeatureTyping") public Namespace getOwningNamespace() { return owningNamespace; } @@ -398,8 +379,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "FeatureTyping") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "FeatureTyping") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -417,8 +398,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "FeatureTyping") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FeatureTyping") public Relationship getOwningRelationship() { return owningRelationship; } @@ -438,8 +419,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "FeatureTyping") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "FeatureTyping") public Type getOwningType() { return owningType; } @@ -479,10 +460,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -498,15 +479,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FeatureTyping") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -527,8 +526,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specificType"), fetch = FetchType.LAZY) - @JoinColumn(name = "specificId", table = "FeatureTyping") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specific_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "specific_id", table = "FeatureTyping") public Type getSpecific() { return specific; } @@ -546,10 +545,10 @@ public void setSpecific(Type specific) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -572,10 +571,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureTyping_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -596,8 +595,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "typeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "typeId", table = "FeatureTyping") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "type_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "type_id", table = "FeatureTyping") public Type getType() { return type; } @@ -615,8 +614,8 @@ public void setType(Type type) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "typedFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "typedFeatureId", table = "FeatureTyping") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "typedFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "typedFeature_id", table = "FeatureTyping") public Feature getTypedFeature() { return typedFeature; } diff --git a/app/org/omg/sysml/metamodel/impl/FeatureValueImpl.java b/app/org/omg/sysml/metamodel/impl/FeatureValueImpl.java index 2d35c694..cfabc21f 100644 --- a/app/org/omg/sysml/metamodel/impl/FeatureValueImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FeatureValueImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FeatureValue") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FeatureValueImpl extends SysMLTypeImpl implements FeatureValue { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FeatureValue_aliasId", - joinColumns = @JoinColumn(name = "FeatureValueId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FeatureValue_aliasIds", + joinColumns = @JoinColumn(name = "FeatureValue_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "FeatureValue") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "FeatureValue") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "FeatureValue") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "FeatureValue") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureWithValueType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureWithValueId", table = "FeatureValue") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureWithValue_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureWithValue_id", table = "FeatureValue") public Feature getFeatureWithValue() { return featureWithValue; } @@ -177,40 +174,6 @@ public void setFeatureWithValue(Feature featureWithValue) { - // @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 = "FeatureValue") - 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 = "FeatureValue") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("isDefault") private Boolean isDefault; @@ -248,8 +211,8 @@ public void setIsInitial(Boolean isInitial) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "FeatureValue") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "FeatureValue") public Element getMemberElement() { return memberElement; } @@ -262,6 +225,26 @@ public void setMemberElement(Element memberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "FeatureValue") + public String getMemberElementId() { + return memberElementId; + } + + @JsonSetter + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("memberName") private String memberName; @@ -280,6 +263,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "FeatureValue") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -287,8 +288,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "FeatureValue") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "FeatureValue") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -301,14 +302,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "FeatureValue") public String getName() { return name; @@ -328,10 +327,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -354,10 +353,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -378,8 +377,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "FeatureValue") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "FeatureValue") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -392,15 +391,75 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "FeatureValue") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "FeatureValue") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "FeatureValue") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -421,10 +480,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -447,8 +506,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FeatureValue") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FeatureValue") public Element getOwner() { return owner; } @@ -462,19 +521,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FeatureValue") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FeatureValue") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -487,8 +546,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FeatureValue") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FeatureValue") public Namespace getOwningNamespace() { return owningNamespace; } @@ -506,8 +565,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "FeatureValue") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "FeatureValue") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -525,8 +584,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "FeatureValue") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FeatureValue") public Relationship getOwningRelationship() { return owningRelationship; } @@ -566,10 +625,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -585,15 +644,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FeatureValue") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -614,10 +691,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -640,10 +717,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FeatureValue_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -664,8 +741,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "valueType"), fetch = FetchType.LAZY) - @JoinColumn(name = "valueId", table = "FeatureValue") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "value_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "value_id", table = "FeatureValue") public Expression getValue() { return value; } diff --git a/app/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl.java index 4f565a69..d263e1a1 100644 --- a/app/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FlowConnectionUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FlowConnectionUsageImpl extends SysMLTypeImpl implements FlowConnectionUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FlowConnectionUsage_aliasId", - joinColumns = @JoinColumn(name = "FlowConnectionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FlowConnectionUsage_aliasIds", + joinColumns = @JoinColumn(name = "FlowConnectionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_connectionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionDefinition() { if (connectionDefinition == null) { connectionDefinition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectionDefinition(List connectionDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -255,10 +256,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -281,10 +282,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -325,10 +326,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -364,6 +365,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "FlowConnectionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -371,10 +388,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -397,8 +414,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "FlowConnectionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "FlowConnectionUsage") public Type getEndOwningType() { return endOwningType; } @@ -418,10 +435,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -470,10 +487,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -489,40 +506,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "FlowConnectionUsage") - 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 = "FlowConnectionUsage") - 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; @@ -530,10 +513,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -556,8 +539,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "FlowConnectionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "FlowConnectionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -577,10 +560,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -603,10 +586,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -629,10 +612,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -901,10 +884,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -927,10 +910,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_itemFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFeature() { if (itemFeature == null) { itemFeature = new ArrayList<>(); @@ -953,10 +936,10 @@ public void setItemFeature(Collection itemFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_itemFlowEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowEnd() { if (itemFlowEnd == null) { itemFlowEnd = new ArrayList<>(); @@ -979,10 +962,10 @@ public void setItemFlowEnd(Collection itemFlowEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_itemFlowFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowFeature() { if (itemFlowFeature == null) { itemFlowFeature = new ArrayList<>(); @@ -1005,10 +988,10 @@ public void setItemFlowFeature(Collection itemFlowFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_itemType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemType() { if (itemType == null) { itemType = new ArrayList<>(); @@ -1031,10 +1014,10 @@ public void setItemType(List itemType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -1057,10 +1040,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1083,8 +1066,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "FlowConnectionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "FlowConnectionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1097,14 +1080,12 @@ public void setMultiplicity(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 = "FlowConnectionUsage") public String getName() { return name; @@ -1124,10 +1105,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1722,10 +1703,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1774,10 +1755,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1800,10 +1781,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1826,10 +1807,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1852,10 +1833,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1878,8 +1859,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "FlowConnectionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "FlowConnectionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1899,10 +1880,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1925,10 +1906,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1951,10 +1932,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -2003,10 +1984,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -2029,10 +2010,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -2055,10 +2036,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2081,10 +2062,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2107,10 +2088,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2133,10 +2114,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2157,10 +2138,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -2181,10 +2162,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2207,10 +2188,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2233,10 +2214,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2259,10 +2240,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2285,10 +2266,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2311,8 +2292,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FlowConnectionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FlowConnectionUsage") public Element getOwner() { return owner; } @@ -2332,8 +2313,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "FlowConnectionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "FlowConnectionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2351,8 +2332,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "FlowConnectionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "FlowConnectionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2366,19 +2347,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FlowConnectionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FlowConnectionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2391,8 +2372,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FlowConnectionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FlowConnectionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2410,8 +2391,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "FlowConnectionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "FlowConnectionUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2429,8 +2410,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "FlowConnectionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FlowConnectionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2450,8 +2431,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "FlowConnectionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "FlowConnectionUsage") public Type getOwningType() { return owningType; } @@ -2471,8 +2452,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "FlowConnectionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "FlowConnectionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2492,10 +2473,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2518,10 +2499,10 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2562,8 +2543,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "FlowConnectionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "FlowConnectionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2603,10 +2584,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2629,10 +2610,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2648,15 +2629,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FlowConnectionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2679,8 +2678,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "FlowConnectionUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "FlowConnectionUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2700,10 +2699,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_sourceOutputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSourceOutputFeature() { if (sourceOutputFeature == null) { sourceOutputFeature = new ArrayList<>(); @@ -2724,10 +2723,10 @@ public void setSourceOutputFeature(List sourceOutputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2750,10 +2749,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2776,10 +2775,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_targetInputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTargetInputFeature() { if (targetInputFeature == null) { targetInputFeature = new ArrayList<>(); @@ -2802,10 +2801,10 @@ public void setTargetInputFeature(List targetInputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2828,10 +2827,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2854,10 +2853,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2880,10 +2879,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2906,10 +2905,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FlowConnectionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl.java index 34c5cb22..0ea645a6 100644 --- a/app/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ForLoopActionUsageImpl extends SysMLTypeImpl implements ForLoopActi @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ForLoopActionUsage_aliasId", - joinColumns = @JoinColumn(name = "ForLoopActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ForLoopActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "ForLoopActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,8 +152,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "bodyActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "bodyActionId", table = "ForLoopActionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "bodyAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "bodyAction_id", table = "ForLoopActionUsage") public ActionUsage getBodyAction() { return bodyAction; } @@ -172,10 +173,10 @@ public void setBodyAction(ActionUsage bodyAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -198,10 +199,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -224,10 +225,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -250,10 +251,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -294,10 +295,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -333,6 +334,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ForLoopActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -340,10 +357,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ForLoopActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ForLoopActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,10 +404,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -458,40 +475,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ForLoopActionUsage") - 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 = "ForLoopActionUsage") - 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; @@ -499,10 +482,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -525,8 +508,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ForLoopActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ForLoopActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -546,10 +529,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -572,10 +555,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -598,10 +581,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -854,8 +837,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "loopVariableType"), fetch = FetchType.LAZY) - @JoinColumn(name = "loopVariableId", table = "ForLoopActionUsage") + @Any(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "loopVariable_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "loopVariable_id", table = "ForLoopActionUsage") public ReferenceUsage getLoopVariable() { return loopVariable; } @@ -875,10 +858,10 @@ public void setLoopVariable(ReferenceUsage loopVariable) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -901,10 +884,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -927,8 +910,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ForLoopActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ForLoopActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -941,14 +924,12 @@ public void setMultiplicity(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 = "ForLoopActionUsage") public String getName() { return name; @@ -968,10 +949,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1722,8 +1703,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ForLoopActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ForLoopActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1743,10 +1724,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1769,10 +1750,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1795,10 +1776,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1821,10 +1802,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1847,10 +1828,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1873,10 +1854,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1899,10 +1880,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1925,10 +1906,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1951,10 +1932,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2001,10 +1982,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2027,10 +2008,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2053,10 +2034,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2079,10 +2060,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2105,10 +2086,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2131,8 +2112,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ForLoopActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ForLoopActionUsage") public Element getOwner() { return owner; } @@ -2152,8 +2133,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ForLoopActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ForLoopActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2171,8 +2152,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ForLoopActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ForLoopActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2186,19 +2167,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ForLoopActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ForLoopActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2211,8 +2192,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ForLoopActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ForLoopActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2230,8 +2211,8 @@ 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 = "ForLoopActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ForLoopActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2251,8 +2232,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ForLoopActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ForLoopActionUsage") public Type getOwningType() { return owningType; } @@ -2272,8 +2253,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ForLoopActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ForLoopActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2293,10 +2274,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2337,8 +2318,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ForLoopActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ForLoopActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2378,8 +2359,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "seqArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "seqArgumentId", table = "ForLoopActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "seqArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "seqArgument_id", table = "ForLoopActionUsage") public Expression getSeqArgument() { return seqArgument; } @@ -2392,6 +2373,24 @@ public void setSeqArgument(Expression seqArgument) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ForLoopActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2399,10 +2398,10 @@ public void setSeqArgument(Expression seqArgument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2425,10 +2424,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2451,10 +2450,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2477,10 +2476,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2503,10 +2502,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForLoopActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ForkNodeImpl.java b/app/org/omg/sysml/metamodel/impl/ForkNodeImpl.java index b6bbc200..a95f6db3 100644 --- a/app/org/omg/sysml/metamodel/impl/ForkNodeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ForkNodeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ForkNodeImpl extends SysMLTypeImpl implements ForkNode { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ForkNode_aliasId", - joinColumns = @JoinColumn(name = "ForkNodeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ForkNode_aliasIds", + joinColumns = @JoinColumn(name = "ForkNode_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ForkNode") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ForkNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ForkNode") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ForkNode") - 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 = "ForkNode") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ForkNode") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ForkNode") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ForkNode") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ForkNode") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "ForkNode") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ForkNode") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ForkNode") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ForkNode") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ForkNode") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ForkNode") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ForkNode") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ForkNode") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ForkNode") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ForkNode") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ForkNode") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ForkNode") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ForkNode") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "ForkNode") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ForkNode") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ForkNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ForkNode") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ForkNode") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ForkNode") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ForkNode") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ForkNode") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2329,6 +2310,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ForkNode") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2336,10 +2335,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ForkNode_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl.java index 97f7db54..e7c68282 100644 --- a/app/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "FramedConcernMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FramedConcernMembershipImpl extends SysMLTypeImpl implements FramedConcernMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "FramedConcernMembership_aliasId", - joinColumns = @JoinColumn(name = "FramedConcernMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "FramedConcernMembership_aliasIds", + joinColumns = @JoinColumn(name = "FramedConcernMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "FramedConcernMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "FramedConcernMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "FramedConcernMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "FramedConcernMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "FramedConcernMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "FramedConcernMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "FramedConcernMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "FramedConcernMembership") public Type getFeaturingType() { return featuringType; } @@ -196,40 +193,6 @@ public void setFeaturingType(Type featuringType) { - // @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 = "FramedConcernMembership") - 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 = "FramedConcernMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("kind") // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) private RequirementConstraintKind kind; @@ -253,8 +216,8 @@ public void setKind(RequirementConstraintKind kind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "FramedConcernMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "FramedConcernMembership") public Element getMemberElement() { return memberElement; } @@ -267,21 +230,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "FramedConcernMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "FramedConcernMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -304,6 +268,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "FramedConcernMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -311,8 +293,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "FramedConcernMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "FramedConcernMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -325,14 +307,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "FramedConcernMembership") public String getName() { return name; @@ -352,10 +332,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -376,8 +356,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConcernType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConcernId", table = "FramedConcernMembership") + @Any(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConcern_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConcern_id", table = "FramedConcernMembership") public ConcernUsage getOwnedConcern() { return ownedConcern; } @@ -395,8 +375,8 @@ public void setOwnedConcern(ConcernUsage ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConstraintId", table = "FramedConcernMembership") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConstraint_id", table = "FramedConcernMembership") public ConstraintUsage getOwnedConstraint() { return ownedConstraint; } @@ -416,10 +396,10 @@ public void setOwnedConstraint(ConstraintUsage ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -440,8 +420,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "FramedConcernMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "FramedConcernMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -454,13 +434,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "FramedConcernMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "FramedConcernMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "FramedConcernMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -473,15 +473,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "FramedConcernMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "FramedConcernMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -502,10 +542,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -528,8 +568,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "FramedConcernMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "FramedConcernMembership") public Element getOwner() { return owner; } @@ -549,8 +589,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "FramedConcernMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "FramedConcernMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -564,19 +604,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "FramedConcernMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "FramedConcernMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -589,8 +629,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "FramedConcernMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "FramedConcernMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -608,8 +648,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "FramedConcernMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "FramedConcernMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -627,8 +667,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "FramedConcernMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "FramedConcernMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -648,8 +688,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "FramedConcernMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "FramedConcernMembership") public Type getOwningType() { return owningType; } @@ -689,8 +729,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConcernType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referencedConcernId", table = "FramedConcernMembership") + @Any(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConcern_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referencedConcern_id", table = "FramedConcernMembership") public ConcernUsage getReferencedConcern() { return referencedConcern; } @@ -710,8 +750,8 @@ public void setReferencedConcern(ConcernUsage referencedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referencedConstraintId", table = "FramedConcernMembership") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referencedConstraint_id", table = "FramedConcernMembership") public ConstraintUsage getReferencedConstraint() { return referencedConstraint; } @@ -731,10 +771,10 @@ public void setReferencedConstraint(ConstraintUsage referencedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -750,15 +790,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "FramedConcernMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -779,10 +837,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -805,10 +863,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "FramedConcernMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/FunctionImpl.java b/app/org/omg/sysml/metamodel/impl/FunctionImpl.java index 4a353cd9..4a692267 100644 --- a/app/org/omg/sysml/metamodel/impl/FunctionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/FunctionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Function") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class FunctionImpl extends SysMLTypeImpl implements Function { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Function_aliasId", - joinColumns = @JoinColumn(name = "FunctionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Function_aliasIds", + joinColumns = @JoinColumn(name = "Function_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Function") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Function") - 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 = "Function") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -481,10 +464,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -507,10 +490,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -533,8 +516,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Function") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Function") public Multiplicity getMultiplicity() { return multiplicity; } @@ -547,14 +530,12 @@ public void setMultiplicity(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 = "Function") public String getName() { return name; @@ -574,10 +555,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -600,10 +581,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -626,8 +607,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Function") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Function") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -647,10 +628,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -673,10 +654,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -699,10 +680,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -725,10 +706,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -751,10 +732,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -803,10 +784,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -829,10 +810,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -853,10 +834,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -879,10 +860,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -905,10 +886,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -931,8 +912,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Function") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Function") public Element getOwner() { return owner; } @@ -946,19 +927,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Function") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Function") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -971,8 +952,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Function") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Function") public Namespace getOwningNamespace() { return owningNamespace; } @@ -990,8 +971,8 @@ 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 = "Function") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Function") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1011,10 +992,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1057,8 +1038,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "Function") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "Function") public Feature getResult() { return result; } @@ -1071,6 +1052,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Function") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1078,10 +1077,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1104,10 +1103,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Function_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/IfActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/IfActionUsageImpl.java index e8a71dda..08d27fcf 100644 --- a/app/org/omg/sysml/metamodel/impl/IfActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/IfActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class IfActionUsageImpl extends SysMLTypeImpl implements IfActionUsage { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "IfActionUsage_aliasId", - joinColumns = @JoinColumn(name = "IfActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "IfActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "IfActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "IfActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("elseAction") private ActionUsage elseAction; @@ -319,8 +336,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "elseActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "elseActionId", table = "IfActionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "elseAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "elseAction_id", table = "IfActionUsage") public ActionUsage getElseAction() { return elseAction; } @@ -340,10 +357,10 @@ public void setElseAction(ActionUsage elseAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "IfActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "IfActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,10 +404,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -458,40 +475,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "IfActionUsage") - 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 = "IfActionUsage") - 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("ifArgument") private Expression ifArgument; @@ -499,8 +482,8 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "ifArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ifArgumentId", table = "IfActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "ifArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ifArgument_id", table = "IfActionUsage") public Expression getIfArgument() { return ifArgument; } @@ -520,10 +503,10 @@ public void setIfArgument(Expression ifArgument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -546,8 +529,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "IfActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "IfActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -567,10 +550,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -593,10 +576,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -619,10 +602,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -875,10 +858,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -901,10 +884,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -927,8 +910,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "IfActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "IfActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -941,14 +924,12 @@ public void setMultiplicity(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 = "IfActionUsage") public String getName() { return name; @@ -968,10 +949,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1722,8 +1703,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "IfActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "IfActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1743,10 +1724,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1769,10 +1750,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1795,10 +1776,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1821,10 +1802,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1847,10 +1828,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1873,10 +1854,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1899,10 +1880,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1925,10 +1906,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1951,10 +1932,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2001,10 +1982,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2027,10 +2008,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2053,10 +2034,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2079,10 +2060,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2105,10 +2086,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2131,8 +2112,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "IfActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "IfActionUsage") public Element getOwner() { return owner; } @@ -2152,8 +2133,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "IfActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "IfActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2171,8 +2152,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "IfActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "IfActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2186,19 +2167,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "IfActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "IfActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2211,8 +2192,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "IfActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "IfActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2230,8 +2211,8 @@ 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 = "IfActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "IfActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2251,8 +2232,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "IfActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "IfActionUsage") public Type getOwningType() { return owningType; } @@ -2272,8 +2253,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "IfActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "IfActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2293,10 +2274,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2337,8 +2318,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "IfActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "IfActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2371,6 +2352,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "IfActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2378,10 +2377,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2404,8 +2403,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "thenActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "thenActionId", table = "IfActionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "thenAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "thenAction_id", table = "IfActionUsage") public ActionUsage getThenAction() { return thenAction; } @@ -2425,10 +2424,10 @@ public void setThenAction(ActionUsage thenAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2451,10 +2450,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2477,10 +2476,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2503,10 +2502,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IfActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ImportImpl.java b/app/org/omg/sysml/metamodel/impl/ImportImpl.java index 5496ebc5..c3c1bf92 100644 --- a/app/org/omg/sysml/metamodel/impl/ImportImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ImportImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Import") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ImportImpl extends SysMLTypeImpl implements Import { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Import_aliasId", - joinColumns = @JoinColumn(name = "ImportId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Import_aliasIds", + joinColumns = @JoinColumn(name = "Import_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,36 +139,18 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Import") - 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 = "Import") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Import") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -179,8 +162,8 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "importOwningNamespaceId", table = "Import") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "importOwningNamespace_id", table = "Import") public Namespace getImportOwningNamespace() { return importOwningNamespace; } @@ -216,8 +199,8 @@ public void setImportedMemberName(String importedMemberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importedNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "importedNamespaceId", table = "Import") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "importedNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "importedNamespace_id", table = "Import") public Namespace getImportedNamespace() { return importedNamespace; } @@ -262,14 +245,12 @@ public void setIsRecursive(Boolean isRecursive) { - // @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 = "Import") public String getName() { return name; @@ -289,10 +270,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -315,10 +296,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -339,10 +320,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -363,10 +344,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -389,8 +370,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Import") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Import") public Element getOwner() { return owner; } @@ -404,19 +385,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Import") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Import") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -429,8 +410,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Import") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Import") public Namespace getOwningNamespace() { return owningNamespace; } @@ -448,8 +429,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Import") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Import") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -467,8 +448,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Import") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Import") public Relationship getOwningRelationship() { return owningRelationship; } @@ -508,10 +489,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -527,15 +508,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Import") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -556,10 +555,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -582,10 +581,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Import_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl.java b/app/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl.java index 318cbb8e..441082b1 100644 --- a/app/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class IncludeUseCaseUsageImpl extends SysMLTypeImpl implements IncludeUse @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setActionDefinition(List actionDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "IncludeUseCaseUsage_aliasId", - joinColumns = @JoinColumn(name = "IncludeUseCaseUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "IncludeUseCaseUsage_aliasIds", + joinColumns = @JoinColumn(name = "IncludeUseCaseUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,8 +178,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "calculationDefinitionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "calculationDefinition_id", table = "IncludeUseCaseUsage") public Function getCalculationDefinition() { return calculationDefinition; } @@ -198,8 +199,8 @@ public void setCalculationDefinition(Function calculationDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "caseDefinitionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "caseDefinition_id", table = "IncludeUseCaseUsage") public CaseDefinition getCaseDefinition() { return caseDefinition; } @@ -219,10 +220,10 @@ public void setCaseDefinition(CaseDefinition caseDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -245,10 +246,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -297,10 +298,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -341,10 +342,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -380,6 +381,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "IncludeUseCaseUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -387,10 +404,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -413,8 +430,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "IncludeUseCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "IncludeUseCaseUsage") public Type getEndOwningType() { return endOwningType; } @@ -434,8 +451,8 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrenceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "eventOccurrenceId", table = "IncludeUseCaseUsage") + @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrence_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "eventOccurrence_id", table = "IncludeUseCaseUsage") public OccurrenceUsage getEventOccurrence() { return eventOccurrence; } @@ -455,10 +472,10 @@ public void setEventOccurrence(OccurrenceUsage eventOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -481,10 +498,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -507,10 +524,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -533,8 +550,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "IncludeUseCaseUsage") public Function getFunction() { return function; } @@ -547,40 +564,6 @@ public void setFunction(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 = "IncludeUseCaseUsage") - 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 = "IncludeUseCaseUsage") - 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; @@ -588,10 +571,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -614,10 +597,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_includedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getIncludedUseCase() { if (includedUseCase == null) { includedUseCase = new ArrayList<>(); @@ -640,8 +623,8 @@ public void setIncludedUseCase(List includedUseCase) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "IncludeUseCaseUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -661,10 +644,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -687,10 +670,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -713,10 +696,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -987,10 +970,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -1013,10 +996,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1039,8 +1022,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "IncludeUseCaseUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "IncludeUseCaseUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1053,14 +1036,12 @@ public void setMultiplicity(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 = "IncludeUseCaseUsage") public String getName() { return name; @@ -1080,10 +1061,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1106,10 +1087,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1132,10 +1113,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1158,10 +1139,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1184,10 +1165,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1210,10 +1191,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1236,10 +1217,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1262,10 +1243,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1288,10 +1269,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1314,10 +1295,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1340,10 +1321,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1366,10 +1347,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1392,10 +1373,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1418,10 +1399,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1444,10 +1425,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1470,10 +1451,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1496,10 +1477,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1522,10 +1503,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1548,10 +1529,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1574,10 +1555,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1600,10 +1581,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1626,10 +1607,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1652,10 +1633,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1678,10 +1659,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1704,10 +1685,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1730,10 +1711,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1756,8 +1737,8 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "IncludeUseCaseUsage") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "IncludeUseCaseUsage") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -1777,10 +1758,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1803,10 +1784,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1829,10 +1810,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1855,8 +1836,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "IncludeUseCaseUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "IncludeUseCaseUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1876,10 +1857,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1902,10 +1883,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1928,10 +1909,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1954,10 +1935,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2058,10 +2039,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2084,10 +2065,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2110,10 +2091,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2134,10 +2115,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2160,10 +2141,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2186,10 +2167,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2212,10 +2193,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2238,10 +2219,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2264,8 +2245,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "IncludeUseCaseUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "IncludeUseCaseUsage") public Element getOwner() { return owner; } @@ -2285,8 +2266,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "IncludeUseCaseUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2304,8 +2285,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "IncludeUseCaseUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "IncludeUseCaseUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2319,19 +2300,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "IncludeUseCaseUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "IncludeUseCaseUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2344,8 +2325,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "IncludeUseCaseUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "IncludeUseCaseUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2363,8 +2344,8 @@ 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 = "IncludeUseCaseUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "IncludeUseCaseUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2384,8 +2365,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "IncludeUseCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "IncludeUseCaseUsage") public Type getOwningType() { return owningType; } @@ -2405,8 +2386,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "IncludeUseCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "IncludeUseCaseUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2426,10 +2407,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2452,8 +2433,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "performedActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "performedActionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "performedAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "performedAction_id", table = "IncludeUseCaseUsage") public ActionUsage getPerformedAction() { return performedAction; } @@ -2491,8 +2472,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "IncludeUseCaseUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "IncludeUseCaseUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2532,8 +2513,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "IncludeUseCaseUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "IncludeUseCaseUsage") public Feature getResult() { return result; } @@ -2546,6 +2527,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "IncludeUseCaseUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("subjectParameter") private Usage subjectParameter; @@ -2553,8 +2552,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "IncludeUseCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "IncludeUseCaseUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2574,10 +2573,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2600,10 +2599,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2626,10 +2625,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2652,8 +2651,8 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UseCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "useCaseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "useCaseDefinitionId", table = "IncludeUseCaseUsage") + @Any(metaDef = "UseCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "useCaseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "useCaseDefinition_id", table = "IncludeUseCaseUsage") public UseCaseDefinition getUseCaseDefinition() { return useCaseDefinition; } @@ -2673,8 +2672,8 @@ public void setUseCaseDefinition(UseCaseDefinition useCaseDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "useCaseIncludedType"), fetch = FetchType.LAZY) - @JoinColumn(name = "useCaseIncludedId", table = "IncludeUseCaseUsage") + @Any(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "useCaseIncluded_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "useCaseIncluded_id", table = "IncludeUseCaseUsage") public UseCaseUsage getUseCaseIncluded() { return useCaseIncluded; } @@ -2694,10 +2693,10 @@ public void setUseCaseIncluded(UseCaseUsage useCaseIncluded) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2720,10 +2719,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "IncludeUseCaseUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/InteractionImpl.java b/app/org/omg/sysml/metamodel/impl/InteractionImpl.java index dc0483c8..af5eba8c 100644 --- a/app/org/omg/sysml/metamodel/impl/InteractionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/InteractionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Interaction") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class InteractionImpl extends SysMLTypeImpl implements Interaction { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Interaction_aliasId", - joinColumns = @JoinColumn(name = "InteractionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Interaction_aliasIds", + joinColumns = @JoinColumn(name = "Interaction_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_associationEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociationEnd() { if (associationEnd == null) { associationEnd = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociationEnd(Collection associationEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Interaction") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Interaction") - 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 = "Interaction") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -489,10 +472,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -515,8 +498,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Interaction") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Interaction") public Multiplicity getMultiplicity() { return multiplicity; } @@ -529,14 +512,12 @@ public void setMultiplicity(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 = "Interaction") public String getName() { return name; @@ -556,10 +537,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -582,10 +563,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -608,8 +589,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Interaction") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Interaction") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -629,10 +610,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -811,10 +792,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -859,10 +840,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -885,10 +866,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -911,10 +892,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -937,8 +918,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Interaction") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Interaction") public Element getOwner() { return owner; } @@ -952,19 +933,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Interaction") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Interaction") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -977,8 +958,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Interaction") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Interaction") public Namespace getOwningNamespace() { return owningNamespace; } @@ -996,8 +977,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Interaction") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Interaction") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1015,8 +996,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Interaction") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Interaction") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1036,10 +1017,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_relatedType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedType() { if (relatedType == null) { relatedType = new ArrayList<>(); @@ -1127,15 +1108,33 @@ public void setRelatedType(List relatedType) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Interaction") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1158,8 +1157,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceTypeId", table = "Interaction") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceType_id", table = "Interaction") public Type getSourceType() { return sourceType; } @@ -1179,10 +1178,10 @@ public void setSourceType(Type sourceType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1203,10 +1202,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1229,10 +1228,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_targetType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetType() { if (targetType == null) { targetType = new ArrayList<>(); @@ -1255,10 +1254,10 @@ public void setTargetType(Collection targetType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Interaction_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl.java index eb383b1c..752af75b 100644 --- a/app/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "InterfaceDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class InterfaceDefinitionImpl extends SysMLTypeImpl implements InterfaceDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "InterfaceDefinition_aliasId", - joinColumns = @JoinColumn(name = "InterfaceDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "InterfaceDefinition_aliasIds", + joinColumns = @JoinColumn(name = "InterfaceDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_associationEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociationEnd() { if (associationEnd == null) { associationEnd = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociationEnd(Collection associationEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_connectionEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionEnd() { if (connectionEnd == null) { connectionEnd = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setConnectionEnd(List connectionEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -242,6 +243,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "InterfaceDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -249,10 +266,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -320,40 +337,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "InterfaceDefinition") - 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 = "InterfaceDefinition") - 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; @@ -361,10 +344,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -413,10 +396,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInput(List input) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_interfaceEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInterfaceEnd() { if (interfaceEnd == null) { interfaceEnd = new ArrayList<>(); @@ -573,8 +556,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "InterfaceDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "InterfaceDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -594,10 +577,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -620,10 +603,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -646,8 +629,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "InterfaceDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "InterfaceDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -660,14 +643,12 @@ public void setMultiplicity(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 = "InterfaceDefinition") public String getName() { return name; @@ -687,10 +668,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -843,10 +824,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -869,10 +850,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -895,10 +876,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -921,8 +902,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "InterfaceDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "InterfaceDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -942,10 +923,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1432,10 +1413,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1458,10 +1439,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1484,10 +1465,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1510,10 +1491,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1536,10 +1517,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1562,10 +1543,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1588,10 +1569,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1614,10 +1595,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1640,10 +1621,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1666,10 +1647,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1692,10 +1673,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1718,10 +1699,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1744,8 +1725,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "InterfaceDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "InterfaceDefinition") public Element getOwner() { return owner; } @@ -1759,19 +1740,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "InterfaceDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "InterfaceDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1784,8 +1765,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "InterfaceDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "InterfaceDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1803,8 +1784,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "InterfaceDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "InterfaceDefinition") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1822,8 +1803,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "InterfaceDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "InterfaceDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1863,10 +1844,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1889,10 +1870,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_relatedType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedType() { if (relatedType == null) { relatedType = new ArrayList<>(); @@ -1908,15 +1889,33 @@ public void setRelatedType(List relatedType) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "InterfaceDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1939,8 +1938,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceTypeId", table = "InterfaceDefinition") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceType_id", table = "InterfaceDefinition") public Type getSourceType() { return sourceType; } @@ -1958,10 +1957,10 @@ public void setSourceType(Type sourceType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1984,10 +1983,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_targetType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetType() { if (targetType == null) { targetType = new ArrayList<>(); @@ -2010,10 +2009,10 @@ public void setTargetType(Collection targetType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2036,10 +2035,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2062,10 +2061,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2088,10 +2087,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/InterfaceUsageImpl.java b/app/org/omg/sysml/metamodel/impl/InterfaceUsageImpl.java index 42d18692..9d21211b 100644 --- a/app/org/omg/sysml/metamodel/impl/InterfaceUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/InterfaceUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "InterfaceUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class InterfaceUsageImpl extends SysMLTypeImpl implements InterfaceUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "InterfaceUsage_aliasId", - joinColumns = @JoinColumn(name = "InterfaceUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "InterfaceUsage_aliasIds", + joinColumns = @JoinColumn(name = "InterfaceUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_connectionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionDefinition() { if (connectionDefinition == null) { connectionDefinition = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectionDefinition(List connectionDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -255,10 +256,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -299,10 +300,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -338,6 +339,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "InterfaceUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -345,10 +362,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -371,8 +388,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "InterfaceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "InterfaceUsage") public Type getEndOwningType() { return endOwningType; } @@ -392,10 +409,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -463,40 +480,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "InterfaceUsage") - 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 = "InterfaceUsage") - 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; @@ -504,10 +487,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -530,8 +513,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "InterfaceUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "InterfaceUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -551,10 +534,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -603,10 +586,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -629,10 +612,10 @@ public void setInput(List input) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_interfaceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getInterfaceDefinition() { if (interfaceDefinition == null) { interfaceDefinition = new ArrayList<>(); @@ -901,10 +884,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -927,10 +910,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -953,10 +936,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -979,8 +962,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "InterfaceUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "InterfaceUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -993,14 +976,12 @@ public void setMultiplicity(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 = "InterfaceUsage") public String getName() { return name; @@ -1020,10 +1001,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1722,10 +1703,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1774,8 +1755,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "InterfaceUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "InterfaceUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1795,10 +1776,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1821,10 +1802,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1847,10 +1828,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1873,10 +1854,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1899,10 +1880,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1925,10 +1906,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1951,10 +1932,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2003,10 +1984,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2029,10 +2010,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2053,10 +2034,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -2077,10 +2058,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2103,10 +2084,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2129,10 +2110,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2155,10 +2136,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2181,10 +2162,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2207,8 +2188,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "InterfaceUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "InterfaceUsage") public Element getOwner() { return owner; } @@ -2228,8 +2209,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "InterfaceUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "InterfaceUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2247,8 +2228,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "InterfaceUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "InterfaceUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2262,19 +2243,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "InterfaceUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "InterfaceUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2287,8 +2268,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "InterfaceUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "InterfaceUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2306,8 +2287,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "InterfaceUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "InterfaceUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2325,8 +2306,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "InterfaceUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "InterfaceUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2346,8 +2327,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "InterfaceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "InterfaceUsage") public Type getOwningType() { return owningType; } @@ -2367,8 +2348,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "InterfaceUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "InterfaceUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2388,10 +2369,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2432,8 +2413,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "InterfaceUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "InterfaceUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2473,10 +2454,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2499,10 +2480,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2518,15 +2499,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "InterfaceUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2549,8 +2548,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "InterfaceUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "InterfaceUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2568,10 +2567,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2594,10 +2593,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2620,10 +2619,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2646,10 +2645,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2672,10 +2671,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2698,10 +2697,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2724,10 +2723,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InterfaceUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/InvariantImpl.java b/app/org/omg/sysml/metamodel/impl/InvariantImpl.java index b37bd556..afdb98bb 100644 --- a/app/org/omg/sysml/metamodel/impl/InvariantImpl.java +++ b/app/org/omg/sysml/metamodel/impl/InvariantImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Invariant") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class InvariantImpl extends SysMLTypeImpl implements Invariant { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Invariant_aliasId", - joinColumns = @JoinColumn(name = "InvariantId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Invariant_aliasIds", + joinColumns = @JoinColumn(name = "Invariant_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Invariant") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Invariant") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Invariant") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "Invariant") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "Invariant") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "Invariant") - 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 = "Invariant") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -739,10 +722,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -765,10 +748,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -791,8 +774,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Invariant") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Invariant") public Multiplicity getMultiplicity() { return multiplicity; } @@ -805,14 +788,12 @@ public void setMultiplicity(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 = "Invariant") public String getName() { return name; @@ -832,10 +813,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -858,10 +839,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -884,8 +865,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Invariant") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Invariant") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -905,10 +886,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -931,10 +912,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -957,10 +938,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1293,8 +1274,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Invariant") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Invariant") public Element getOwner() { return owner; } @@ -1312,8 +1293,8 @@ 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 = "Invariant") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Invariant") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1327,19 +1308,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Invariant") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Invariant") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1352,8 +1333,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Invariant") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Invariant") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1371,8 +1352,8 @@ 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 = "Invariant") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Invariant") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1392,8 +1373,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Invariant") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Invariant") public Type getOwningType() { return owningType; } @@ -1413,10 +1394,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1439,8 +1420,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "Invariant") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "Invariant") public Predicate getPredicate() { return predicate; } @@ -1480,8 +1461,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "Invariant") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "Invariant") public Feature getResult() { return result; } @@ -1494,6 +1475,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Invariant") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1501,10 +1500,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1527,10 +1526,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Invariant_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/InvocationExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/InvocationExpressionImpl.java index 1f93789c..7e5709a0 100644 --- a/app/org/omg/sysml/metamodel/impl/InvocationExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/InvocationExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "InvocationExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class InvocationExpressionImpl extends SysMLTypeImpl implements InvocationExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "InvocationExpression_aliasId", - joinColumns = @JoinColumn(name = "InvocationExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "InvocationExpression_aliasIds", + joinColumns = @JoinColumn(name = "InvocationExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_argument", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getArgument() { if (argument == null) { argument = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setArgument(List argument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "InvocationExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "InvocationExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "InvocationExpression") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "InvocationExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "InvocationExpression") public Function getFunction() { return function; } @@ -406,40 +423,6 @@ public void setFunction(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 = "InvocationExpression") - 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 = "InvocationExpression") - 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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -775,10 +758,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -801,8 +784,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "InvocationExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "InvocationExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -815,14 +798,12 @@ public void setMultiplicity(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 = "InvocationExpression") public String getName() { return name; @@ -842,10 +823,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -868,10 +849,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -894,8 +875,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "InvocationExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "InvocationExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -915,10 +896,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1149,10 +1130,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1277,10 +1258,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1303,8 +1284,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "InvocationExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "InvocationExpression") public Element getOwner() { return owner; } @@ -1322,8 +1303,8 @@ 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 = "InvocationExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "InvocationExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1337,19 +1318,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "InvocationExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "InvocationExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1362,8 +1343,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "InvocationExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "InvocationExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1381,8 +1362,8 @@ 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 = "InvocationExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "InvocationExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1402,8 +1383,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "InvocationExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "InvocationExpression") public Type getOwningType() { return owningType; } @@ -1423,10 +1404,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1469,8 +1450,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "InvocationExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "InvocationExpression") public Feature getResult() { return result; } @@ -1483,6 +1464,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "InvocationExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1490,10 +1489,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1516,10 +1515,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "InvocationExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ItemDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ItemDefinitionImpl.java index e67d64f3..b933ff74 100644 --- a/app/org/omg/sysml/metamodel/impl/ItemDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ItemDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ItemDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ItemDefinitionImpl extends SysMLTypeImpl implements ItemDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ItemDefinition_aliasId", - joinColumns = @JoinColumn(name = "ItemDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ItemDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ItemDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ItemDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "ItemDefinition") - 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 = "ItemDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -495,8 +478,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ItemDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ItemDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -516,10 +499,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -542,10 +525,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -568,8 +551,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ItemDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ItemDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -582,14 +565,12 @@ public void setMultiplicity(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 = "ItemDefinition") public String getName() { return name; @@ -609,10 +590,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -635,10 +616,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -843,8 +824,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ItemDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ItemDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -864,10 +845,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -890,10 +871,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1642,8 +1623,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ItemDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ItemDefinition") public Element getOwner() { return owner; } @@ -1657,19 +1638,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ItemDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ItemDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1682,8 +1663,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ItemDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ItemDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1701,8 +1682,8 @@ 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 = "ItemDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ItemDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1735,6 +1716,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ItemDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1742,10 +1741,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1768,10 +1767,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1794,10 +1793,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ItemFeatureImpl.java b/app/org/omg/sysml/metamodel/impl/ItemFeatureImpl.java index 459d1e85..b8212c1c 100644 --- a/app/org/omg/sysml/metamodel/impl/ItemFeatureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ItemFeatureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ItemFeature") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ItemFeatureImpl extends SysMLTypeImpl implements ItemFeature { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ItemFeature_aliasId", - joinColumns = @JoinColumn(name = "ItemFeatureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ItemFeature_aliasIds", + joinColumns = @JoinColumn(name = "ItemFeature_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ItemFeature") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ItemFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ItemFeature") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ItemFeature") - 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 = "ItemFeature") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ItemFeature") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ItemFeature") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "ItemFeature") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ItemFeature") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ItemFeature") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ItemFeature") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ItemFeature") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "ItemFeature") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ItemFeature") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ItemFeature") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ItemFeature") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ItemFeature") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ItemFeature") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "ItemFeature") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ItemFeature") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ItemFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ItemFeature") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ItemFeature") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFeature_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ItemFlowEndImpl.java b/app/org/omg/sysml/metamodel/impl/ItemFlowEndImpl.java index 70e7ac8b..ad46fb1c 100644 --- a/app/org/omg/sysml/metamodel/impl/ItemFlowEndImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ItemFlowEndImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ItemFlowEnd") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ItemFlowEndImpl extends SysMLTypeImpl implements ItemFlowEnd { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ItemFlowEnd_aliasId", - joinColumns = @JoinColumn(name = "ItemFlowEndId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ItemFlowEnd_aliasIds", + joinColumns = @JoinColumn(name = "ItemFlowEnd_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ItemFlowEnd") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ItemFlowEnd") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ItemFlowEnd") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ItemFlowEnd") - 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 = "ItemFlowEnd") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ItemFlowEnd") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ItemFlowEnd") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "ItemFlowEnd") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ItemFlowEnd") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ItemFlowEnd") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ItemFlowEnd") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ItemFlowEnd") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "ItemFlowEnd") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ItemFlowEnd") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ItemFlowEnd") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ItemFlowEnd") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ItemFlowEnd") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ItemFlowEnd") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "ItemFlowEnd") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ItemFlowEnd") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ItemFlowEnd") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ItemFlowEnd") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ItemFlowEnd") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowEnd_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl.java b/app/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl.java index a4c5ac87..2ac4a45c 100644 --- a/app/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ItemFlowFeature") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ItemFlowFeatureImpl extends SysMLTypeImpl implements ItemFlowFeature { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ItemFlowFeature_aliasId", - joinColumns = @JoinColumn(name = "ItemFlowFeatureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ItemFlowFeature_aliasIds", + joinColumns = @JoinColumn(name = "ItemFlowFeature_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ItemFlowFeature") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ItemFlowFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ItemFlowFeature") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ItemFlowFeature") - 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 = "ItemFlowFeature") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ItemFlowFeature") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ItemFlowFeature") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "ItemFlowFeature") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ItemFlowFeature") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ItemFlowFeature") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ItemFlowFeature") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ItemFlowFeature") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "ItemFlowFeature") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ItemFlowFeature") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ItemFlowFeature") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ItemFlowFeature") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ItemFlowFeature") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ItemFlowFeature") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "ItemFlowFeature") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ItemFlowFeature") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ItemFlowFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ItemFlowFeature") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ItemFlowFeature") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlowFeature_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ItemFlowImpl.java b/app/org/omg/sysml/metamodel/impl/ItemFlowImpl.java index 44bac26e..93d72bcc 100644 --- a/app/org/omg/sysml/metamodel/impl/ItemFlowImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ItemFlowImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ItemFlow") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ItemFlowImpl extends SysMLTypeImpl implements ItemFlow { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ItemFlow_aliasId", - joinColumns = @JoinColumn(name = "ItemFlowId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ItemFlow_aliasIds", + joinColumns = @JoinColumn(name = "ItemFlow_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -247,10 +248,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -286,6 +287,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ItemFlow") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -293,10 +310,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -319,8 +336,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ItemFlow") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ItemFlow") public Type getEndOwningType() { return endOwningType; } @@ -340,10 +357,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -411,40 +428,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ItemFlow") - 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 = "ItemFlow") - 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; @@ -452,10 +435,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -530,10 +513,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -752,10 +735,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_itemFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFeature() { if (itemFeature == null) { itemFeature = new ArrayList<>(); @@ -778,10 +761,10 @@ public void setItemFeature(Collection itemFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_itemFlowEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowEnd() { if (itemFlowEnd == null) { itemFlowEnd = new ArrayList<>(); @@ -804,10 +787,10 @@ public void setItemFlowEnd(Collection itemFlowEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_itemFlowFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowFeature() { if (itemFlowFeature == null) { itemFlowFeature = new ArrayList<>(); @@ -830,10 +813,10 @@ public void setItemFlowFeature(Collection itemFlowFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_itemType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemType() { if (itemType == null) { itemType = new ArrayList<>(); @@ -856,10 +839,10 @@ public void setItemType(List itemType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -882,10 +865,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -908,8 +891,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ItemFlow") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ItemFlow") public Multiplicity getMultiplicity() { return multiplicity; } @@ -922,14 +905,12 @@ public void setMultiplicity(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 = "ItemFlow") public String getName() { return name; @@ -949,10 +930,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -975,10 +956,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1001,8 +982,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ItemFlow") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ItemFlow") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1022,10 +1003,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1048,10 +1029,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1074,10 +1055,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1100,10 +1081,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1126,10 +1107,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1152,10 +1133,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1178,10 +1159,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1204,10 +1185,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1230,10 +1211,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1256,10 +1237,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1304,10 +1285,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1434,8 +1415,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ItemFlow") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ItemFlow") public Element getOwner() { return owner; } @@ -1453,8 +1434,8 @@ 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 = "ItemFlow") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ItemFlow") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1468,19 +1449,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ItemFlow") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ItemFlow") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1493,8 +1474,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ItemFlow") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ItemFlow") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1512,8 +1493,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ItemFlow") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ItemFlow") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1531,8 +1512,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ItemFlow") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ItemFlow") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1552,8 +1533,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ItemFlow") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ItemFlow") public Type getOwningType() { return owningType; } @@ -1573,10 +1554,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1619,10 +1600,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1645,10 +1626,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -1664,15 +1645,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ItemFlow") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1695,8 +1694,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "ItemFlow") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "ItemFlow") public Feature getSourceFeature() { return sourceFeature; } @@ -1716,10 +1715,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_sourceOutputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSourceOutputFeature() { if (sourceOutputFeature == null) { sourceOutputFeature = new ArrayList<>(); @@ -1740,10 +1739,10 @@ public void setSourceOutputFeature(List sourceOutputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1766,10 +1765,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -1792,10 +1791,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_targetInputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTargetInputFeature() { if (targetInputFeature == null) { targetInputFeature = new ArrayList<>(); @@ -1818,10 +1817,10 @@ public void setTargetInputFeature(List targetInputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1844,10 +1843,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemFlow_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ItemUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ItemUsageImpl.java index 096dbc63..b352c641 100644 --- a/app/org/omg/sysml/metamodel/impl/ItemUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ItemUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ItemUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ItemUsageImpl extends SysMLTypeImpl implements ItemUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ItemUsage_aliasId", - joinColumns = @JoinColumn(name = "ItemUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ItemUsage_aliasIds", + joinColumns = @JoinColumn(name = "ItemUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ItemUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ItemUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ItemUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ItemUsage") - 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 = "ItemUsage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,8 +435,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ItemUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ItemUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -473,10 +456,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -781,10 +764,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -807,10 +790,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -859,8 +842,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ItemUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ItemUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -873,14 +856,12 @@ public void setMultiplicity(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 = "ItemUsage") public String getName() { return name; @@ -900,10 +881,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -926,10 +907,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1654,8 +1635,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ItemUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ItemUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1675,10 +1656,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1701,10 +1682,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2063,8 +2044,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ItemUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ItemUsage") public Element getOwner() { return owner; } @@ -2084,8 +2065,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ItemUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ItemUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2103,8 +2084,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ItemUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ItemUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2118,19 +2099,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ItemUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ItemUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2143,8 +2124,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ItemUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ItemUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2162,8 +2143,8 @@ 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 = "ItemUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ItemUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2183,8 +2164,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ItemUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ItemUsage") public Type getOwningType() { return owningType; } @@ -2204,8 +2185,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ItemUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ItemUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2243,8 +2224,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ItemUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ItemUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2277,6 +2258,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ItemUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2284,10 +2283,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2310,10 +2309,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2336,10 +2335,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ItemUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/JoinNodeImpl.java b/app/org/omg/sysml/metamodel/impl/JoinNodeImpl.java index f94e3840..b0d1fea8 100644 --- a/app/org/omg/sysml/metamodel/impl/JoinNodeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/JoinNodeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class JoinNodeImpl extends SysMLTypeImpl implements JoinNode { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "JoinNode_aliasId", - joinColumns = @JoinColumn(name = "JoinNodeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "JoinNode_aliasIds", + joinColumns = @JoinColumn(name = "JoinNode_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "JoinNode") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "JoinNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "JoinNode") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "JoinNode") - 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 = "JoinNode") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "JoinNode") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "JoinNode") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "JoinNode") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "JoinNode") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "JoinNode") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "JoinNode") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "JoinNode") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "JoinNode") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "JoinNode") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "JoinNode") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "JoinNode") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "JoinNode") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "JoinNode") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "JoinNode") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "JoinNode") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "JoinNode") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "JoinNode") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "JoinNode") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "JoinNode") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "JoinNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "JoinNode") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "JoinNode") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "JoinNode") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "JoinNode") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "JoinNode") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2329,6 +2310,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "JoinNode") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2336,10 +2335,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "JoinNode_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LifeClassImpl.java b/app/org/omg/sysml/metamodel/impl/LifeClassImpl.java index 3e149ec3..d8448edd 100644 --- a/app/org/omg/sysml/metamodel/impl/LifeClassImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LifeClassImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LifeClass") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LifeClassImpl extends SysMLTypeImpl implements LifeClass { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LifeClass_aliasId", - joinColumns = @JoinColumn(name = "LifeClassId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LifeClass_aliasIds", + joinColumns = @JoinColumn(name = "LifeClass_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LifeClass") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "LifeClass") - 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 = "LifeClass") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LifeClass") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LifeClass") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "LifeClass") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LifeClass") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LifeClass") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LifeClass") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LifeClass") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LifeClass") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LifeClass") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LifeClass") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LifeClass") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "LifeClass") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LifeClass") public Relationship getOwningRelationship() { return owningRelationship; } @@ -980,6 +961,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LifeClass") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -987,10 +986,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LifeClass_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LiteralBooleanImpl.java b/app/org/omg/sysml/metamodel/impl/LiteralBooleanImpl.java index d3a605f4..344706cb 100644 --- a/app/org/omg/sysml/metamodel/impl/LiteralBooleanImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LiteralBooleanImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LiteralBoolean") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LiteralBooleanImpl extends SysMLTypeImpl implements LiteralBoolean { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LiteralBoolean_aliasId", - joinColumns = @JoinColumn(name = "LiteralBooleanId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LiteralBoolean_aliasIds", + joinColumns = @JoinColumn(name = "LiteralBoolean_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LiteralBoolean") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LiteralBoolean") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LiteralBoolean") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "LiteralBoolean") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "LiteralBoolean") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "LiteralBoolean") - 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 = "LiteralBoolean") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LiteralBoolean") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LiteralBoolean") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "LiteralBoolean") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LiteralBoolean") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LiteralBoolean") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LiteralBoolean") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LiteralBoolean") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "LiteralBoolean") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LiteralBoolean") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LiteralBoolean") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LiteralBoolean") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LiteralBoolean") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LiteralBoolean") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "LiteralBoolean") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LiteralBoolean") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LiteralBoolean") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LiteralBoolean") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "LiteralBoolean") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "LiteralBoolean") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LiteralBoolean") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralBoolean_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LiteralExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/LiteralExpressionImpl.java index 123d5f22..7dcee792 100644 --- a/app/org/omg/sysml/metamodel/impl/LiteralExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LiteralExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LiteralExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LiteralExpressionImpl extends SysMLTypeImpl implements LiteralExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LiteralExpression_aliasId", - joinColumns = @JoinColumn(name = "LiteralExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LiteralExpression_aliasIds", + joinColumns = @JoinColumn(name = "LiteralExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LiteralExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LiteralExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LiteralExpression") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "LiteralExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "LiteralExpression") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "LiteralExpression") - 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 = "LiteralExpression") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LiteralExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LiteralExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "LiteralExpression") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LiteralExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LiteralExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LiteralExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LiteralExpression") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "LiteralExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LiteralExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LiteralExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LiteralExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LiteralExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LiteralExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "LiteralExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LiteralExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LiteralExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LiteralExpression") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "LiteralExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "LiteralExpression") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LiteralExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LiteralInfinityImpl.java b/app/org/omg/sysml/metamodel/impl/LiteralInfinityImpl.java index 7b675464..ea876135 100644 --- a/app/org/omg/sysml/metamodel/impl/LiteralInfinityImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LiteralInfinityImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LiteralInfinity") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LiteralInfinityImpl extends SysMLTypeImpl implements LiteralInfinity { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LiteralInfinity_aliasId", - joinColumns = @JoinColumn(name = "LiteralInfinityId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LiteralInfinity_aliasIds", + joinColumns = @JoinColumn(name = "LiteralInfinity_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LiteralInfinity") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LiteralInfinity") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LiteralInfinity") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "LiteralInfinity") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "LiteralInfinity") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "LiteralInfinity") - 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 = "LiteralInfinity") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LiteralInfinity") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LiteralInfinity") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "LiteralInfinity") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LiteralInfinity") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LiteralInfinity") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LiteralInfinity") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LiteralInfinity") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "LiteralInfinity") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LiteralInfinity") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LiteralInfinity") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LiteralInfinity") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LiteralInfinity") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LiteralInfinity") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "LiteralInfinity") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LiteralInfinity") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LiteralInfinity") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LiteralInfinity") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "LiteralInfinity") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "LiteralInfinity") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LiteralInfinity") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInfinity_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LiteralIntegerImpl.java b/app/org/omg/sysml/metamodel/impl/LiteralIntegerImpl.java index 5377ccf6..baf7250e 100644 --- a/app/org/omg/sysml/metamodel/impl/LiteralIntegerImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LiteralIntegerImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LiteralInteger") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LiteralIntegerImpl extends SysMLTypeImpl implements LiteralInteger { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LiteralInteger_aliasId", - joinColumns = @JoinColumn(name = "LiteralIntegerId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LiteralInteger_aliasIds", + joinColumns = @JoinColumn(name = "LiteralInteger_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LiteralInteger") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LiteralInteger") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LiteralInteger") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "LiteralInteger") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "LiteralInteger") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "LiteralInteger") - 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 = "LiteralInteger") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LiteralInteger") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LiteralInteger") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "LiteralInteger") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LiteralInteger") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LiteralInteger") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LiteralInteger") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LiteralInteger") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "LiteralInteger") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LiteralInteger") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LiteralInteger") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LiteralInteger") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LiteralInteger") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LiteralInteger") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "LiteralInteger") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LiteralInteger") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LiteralInteger") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LiteralInteger") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "LiteralInteger") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "LiteralInteger") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LiteralInteger") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralInteger_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LiteralRationalImpl.java b/app/org/omg/sysml/metamodel/impl/LiteralRationalImpl.java index 2e22c2f8..23d11195 100644 --- a/app/org/omg/sysml/metamodel/impl/LiteralRationalImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LiteralRationalImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LiteralRational") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LiteralRationalImpl extends SysMLTypeImpl implements LiteralRational { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LiteralRational_aliasId", - joinColumns = @JoinColumn(name = "LiteralRationalId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LiteralRational_aliasIds", + joinColumns = @JoinColumn(name = "LiteralRational_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LiteralRational") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LiteralRational") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LiteralRational") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "LiteralRational") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "LiteralRational") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "LiteralRational") - 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 = "LiteralRational") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LiteralRational") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LiteralRational") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "LiteralRational") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LiteralRational") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LiteralRational") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LiteralRational") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LiteralRational") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "LiteralRational") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LiteralRational") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LiteralRational") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LiteralRational") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LiteralRational") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LiteralRational") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "LiteralRational") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LiteralRational") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LiteralRational") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LiteralRational") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "LiteralRational") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "LiteralRational") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LiteralRational") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralRational_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LiteralStringImpl.java b/app/org/omg/sysml/metamodel/impl/LiteralStringImpl.java index 6b22f623..b2e8556b 100644 --- a/app/org/omg/sysml/metamodel/impl/LiteralStringImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LiteralStringImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "LiteralString") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class LiteralStringImpl extends SysMLTypeImpl implements LiteralString { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LiteralString_aliasId", - joinColumns = @JoinColumn(name = "LiteralStringId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LiteralString_aliasIds", + joinColumns = @JoinColumn(name = "LiteralString_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LiteralString") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LiteralString") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LiteralString") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "LiteralString") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "LiteralString") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "LiteralString") - 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 = "LiteralString") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LiteralString") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LiteralString") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "LiteralString") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LiteralString") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LiteralString") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LiteralString") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LiteralString") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "LiteralString") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LiteralString") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LiteralString") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LiteralString") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LiteralString") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LiteralString") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "LiteralString") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LiteralString") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LiteralString") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LiteralString") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "LiteralString") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "LiteralString") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LiteralString") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LiteralString_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/LoopActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/LoopActionUsageImpl.java index 3a5dcb41..cb997fbc 100644 --- a/app/org/omg/sysml/metamodel/impl/LoopActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/LoopActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public abstract class LoopActionUsageImpl extends SysMLTypeImpl implements LoopA @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "LoopActionUsage_aliasId", - joinColumns = @JoinColumn(name = "LoopActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "LoopActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "LoopActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,8 +152,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "bodyActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "bodyActionId", table = "LoopActionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "bodyAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "bodyAction_id", table = "LoopActionUsage") public ActionUsage getBodyAction() { return bodyAction; } @@ -172,10 +173,10 @@ public void setBodyAction(ActionUsage bodyAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -198,10 +199,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -224,10 +225,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -250,10 +251,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -294,10 +295,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -333,6 +334,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "LoopActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -340,10 +357,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "LoopActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "LoopActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,10 +404,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -458,40 +475,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "LoopActionUsage") - 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 = "LoopActionUsage") - 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; @@ -499,10 +482,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -525,8 +508,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "LoopActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "LoopActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -546,10 +529,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -572,10 +555,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -598,10 +581,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -854,10 +837,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -880,10 +863,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -906,8 +889,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "LoopActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "LoopActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -920,14 +903,12 @@ public void setMultiplicity(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 = "LoopActionUsage") public String getName() { return name; @@ -947,10 +928,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -973,10 +954,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -999,10 +980,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1025,10 +1006,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1051,10 +1032,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1077,10 +1058,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1103,10 +1084,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1129,10 +1110,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1155,10 +1136,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1181,10 +1162,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1207,10 +1188,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1233,10 +1214,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1259,10 +1240,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1285,10 +1266,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1311,10 +1292,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1337,10 +1318,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1363,10 +1344,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1389,10 +1370,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1415,10 +1396,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1441,10 +1422,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1467,10 +1448,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1493,10 +1474,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1519,10 +1500,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1545,10 +1526,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1571,10 +1552,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1597,10 +1578,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1623,10 +1604,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1649,10 +1630,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1675,10 +1656,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1701,8 +1682,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "LoopActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "LoopActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1722,10 +1703,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1774,10 +1755,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1800,10 +1781,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1826,10 +1807,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1852,10 +1833,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1878,10 +1859,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1904,10 +1885,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1930,10 +1911,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1956,10 +1937,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2058,10 +2039,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2084,10 +2065,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2110,8 +2091,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "LoopActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "LoopActionUsage") public Element getOwner() { return owner; } @@ -2131,8 +2112,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "LoopActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "LoopActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2150,8 +2131,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "LoopActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "LoopActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2165,19 +2146,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "LoopActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "LoopActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2190,8 +2171,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "LoopActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "LoopActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2209,8 +2190,8 @@ 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 = "LoopActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "LoopActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2230,8 +2211,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "LoopActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "LoopActionUsage") public Type getOwningType() { return owningType; } @@ -2251,8 +2232,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "LoopActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "LoopActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2272,10 +2253,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2316,8 +2297,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "LoopActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "LoopActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2350,6 +2331,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "LoopActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2357,10 +2356,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2383,10 +2382,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2409,10 +2408,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2435,10 +2434,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2461,10 +2460,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "LoopActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MembershipImpl.java b/app/org/omg/sysml/metamodel/impl/MembershipImpl.java index 3a00c251..61a163dd 100644 --- a/app/org/omg/sysml/metamodel/impl/MembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Membership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MembershipImpl extends SysMLTypeImpl implements Membership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Membership_aliasId", - joinColumns = @JoinColumn(name = "MembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Membership_aliasIds", + joinColumns = @JoinColumn(name = "Membership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -118,26 +119,6 @@ public void setDocumentation(List documentation) { - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; - - @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveMemberName", table = "Membership") - public String getEffectiveMemberName() { - return effectiveMemberName; - } - - @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; - } - - - // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("effectiveName") private String effectiveName; @@ -158,55 +139,57 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Membership") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "Membership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("memberElement") + private Element memberElement; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "Membership") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "Membership") + public Element getMemberElement() { + return memberElement; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setMemberElement(Element memberElement) { + this.memberElement = memberElement; } - // @info.archinnov.achilles.annotations.Column("memberElement") - private Element memberElement; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "Membership") - public Element getMemberElement() { - return memberElement; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "Membership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) - public void setMemberElement(Element memberElement) { - this.memberElement = memberElement; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -229,6 +212,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "Membership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -236,8 +237,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "Membership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "Membership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -250,14 +251,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "Membership") public String getName() { return name; @@ -277,10 +276,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -303,10 +302,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -322,34 +321,15 @@ public void setOwnedElement(List ownedElement) { - // @info.archinnov.achilles.annotations.Column("ownedMemberElement") - private Element ownedMemberElement; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "Membership") - public Element getOwnedMemberElement() { - return ownedMemberElement; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) - public void setOwnedMemberElement(Element ownedMemberElement) { - this.ownedMemberElement = ownedMemberElement; - } - - - // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -370,10 +350,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -396,8 +376,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Membership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Membership") public Element getOwner() { return owner; } @@ -411,19 +391,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Membership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Membership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -436,8 +416,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Membership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Membership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -455,8 +435,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Membership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Membership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -474,8 +454,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Membership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Membership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -515,10 +495,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -534,15 +514,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Membership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -563,10 +561,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -589,10 +587,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Membership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MergeNodeImpl.java b/app/org/omg/sysml/metamodel/impl/MergeNodeImpl.java index 4837fe93..1763d4ad 100644 --- a/app/org/omg/sysml/metamodel/impl/MergeNodeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MergeNodeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class MergeNodeImpl extends SysMLTypeImpl implements MergeNode { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "MergeNode_aliasId", - joinColumns = @JoinColumn(name = "MergeNodeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "MergeNode_aliasIds", + joinColumns = @JoinColumn(name = "MergeNode_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "MergeNode") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "MergeNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "MergeNode") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "MergeNode") - 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 = "MergeNode") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "MergeNode") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "MergeNode") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "MergeNode") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "MergeNode") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "MergeNode") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "MergeNode") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "MergeNode") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "MergeNode") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "MergeNode") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "MergeNode") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "MergeNode") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "MergeNode") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "MergeNode") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "MergeNode") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "MergeNode") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "MergeNode") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "MergeNode") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "MergeNode") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "MergeNode") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "MergeNode") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "MergeNode") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "MergeNode") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "MergeNode") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "MergeNode") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "MergeNode") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2329,6 +2310,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "MergeNode") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2336,10 +2335,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MergeNode_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MetaclassImpl.java b/app/org/omg/sysml/metamodel/impl/MetaclassImpl.java index d1ec9294..ab34705f 100644 --- a/app/org/omg/sysml/metamodel/impl/MetaclassImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MetaclassImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Metaclass") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MetaclassImpl extends SysMLTypeImpl implements Metaclass { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Metaclass_aliasId", - joinColumns = @JoinColumn(name = "MetaclassId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Metaclass_aliasIds", + joinColumns = @JoinColumn(name = "Metaclass_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Metaclass") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Metaclass") - 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 = "Metaclass") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Metaclass") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Metaclass") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "Metaclass") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Metaclass") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Metaclass") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Metaclass") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Metaclass") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Metaclass") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Metaclass") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Metaclass") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Metaclass") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "Metaclass") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Metaclass") public Relationship getOwningRelationship() { return owningRelationship; } @@ -980,6 +961,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Metaclass") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -987,10 +986,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Metaclass_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl.java index e216341c..1a0c1a8e 100644 --- a/app/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "MetadataDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MetadataDefinitionImpl extends SysMLTypeImpl implements MetadataDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "MetadataDefinition_aliasId", - joinColumns = @JoinColumn(name = "MetadataDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "MetadataDefinition_aliasIds", + joinColumns = @JoinColumn(name = "MetadataDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "MetadataDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "MetadataDefinition") - 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 = "MetadataDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -495,8 +478,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "MetadataDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "MetadataDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -516,10 +499,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -542,10 +525,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -568,8 +551,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "MetadataDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "MetadataDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -582,14 +565,12 @@ public void setMultiplicity(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 = "MetadataDefinition") public String getName() { return name; @@ -609,10 +590,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -635,10 +616,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -843,8 +824,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "MetadataDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "MetadataDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -864,10 +845,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -890,10 +871,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1642,8 +1623,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "MetadataDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "MetadataDefinition") public Element getOwner() { return owner; } @@ -1657,19 +1638,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "MetadataDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "MetadataDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1682,8 +1663,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "MetadataDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "MetadataDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1701,8 +1682,8 @@ 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 = "MetadataDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "MetadataDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1735,6 +1716,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "MetadataDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1742,10 +1741,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1768,10 +1767,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1794,10 +1793,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MetadataFeatureImpl.java b/app/org/omg/sysml/metamodel/impl/MetadataFeatureImpl.java index 9b682fb2..19a306cf 100644 --- a/app/org/omg/sysml/metamodel/impl/MetadataFeatureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MetadataFeatureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "MetadataFeature") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MetadataFeatureImpl extends SysMLTypeImpl implements MetadataFeature { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "MetadataFeature_aliasId", - joinColumns = @JoinColumn(name = "MetadataFeatureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "MetadataFeature_aliasIds", + joinColumns = @JoinColumn(name = "MetadataFeature_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_annotatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotatedElement() { if (annotatedElement == null) { annotatedElement = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setAnnotatedElement(List annotatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_annotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotation() { if (annotation == null) { annotation = new ArrayList<>(); @@ -149,10 +150,10 @@ public void setAnnotation(List annotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -175,10 +176,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -219,10 +220,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -258,6 +259,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "MetadataFeature") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -265,10 +282,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -291,8 +308,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "MetadataFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "MetadataFeature") public Type getEndOwningType() { return endOwningType; } @@ -312,10 +329,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -338,10 +355,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -364,10 +381,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -383,40 +400,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "MetadataFeature") - 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 = "MetadataFeature") - 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; @@ -424,10 +407,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -450,10 +433,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -476,10 +459,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -502,10 +485,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -708,10 +691,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -734,10 +717,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -760,8 +743,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MetaclassMetaDef", metaColumn = @javax.persistence.Column(name = "metaclassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "metaclassId", table = "MetadataFeature") + @Any(metaDef = "MetaclassMetaDef", metaColumn = @javax.persistence.Column(name = "metaclass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "metaclass_id", table = "MetadataFeature") public Metaclass getMetaclass() { return metaclass; } @@ -781,8 +764,8 @@ public void setMetaclass(Metaclass metaclass) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "MetadataFeature") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "MetadataFeature") public Multiplicity getMultiplicity() { return multiplicity; } @@ -795,14 +778,12 @@ public void setMultiplicity(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 = "MetadataFeature") public String getName() { return name; @@ -822,10 +803,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -848,10 +829,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -874,8 +855,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "MetadataFeature") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "MetadataFeature") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -895,10 +876,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -921,10 +902,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -947,10 +928,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -973,10 +954,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -999,10 +980,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1025,10 +1006,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1051,10 +1032,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1077,10 +1058,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1103,10 +1084,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1129,10 +1110,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1153,10 +1134,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1179,10 +1160,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1205,10 +1186,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1231,10 +1212,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1257,10 +1238,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1283,8 +1264,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "MetadataFeature") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "MetadataFeature") public Element getOwner() { return owner; } @@ -1302,8 +1283,8 @@ 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 = "MetadataFeature") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "MetadataFeature") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1317,19 +1298,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "MetadataFeature") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "MetadataFeature") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1342,8 +1323,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "MetadataFeature") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "MetadataFeature") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1361,8 +1342,8 @@ 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 = "MetadataFeature") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "MetadataFeature") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1382,8 +1363,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "MetadataFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "MetadataFeature") public Type getOwningType() { return owningType; } @@ -1416,6 +1397,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "MetadataFeature") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1423,10 +1422,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1449,10 +1448,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataFeature_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MetadataUsageImpl.java b/app/org/omg/sysml/metamodel/impl/MetadataUsageImpl.java index 1d887965..3767fc49 100644 --- a/app/org/omg/sysml/metamodel/impl/MetadataUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MetadataUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "MetadataUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MetadataUsageImpl extends SysMLTypeImpl implements MetadataUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "MetadataUsage_aliasId", - joinColumns = @JoinColumn(name = "MetadataUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "MetadataUsage_aliasIds", + joinColumns = @JoinColumn(name = "MetadataUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_annotatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotatedElement() { if (annotatedElement == null) { annotatedElement = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setAnnotatedElement(List annotatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_annotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotation() { if (annotation == null) { annotation = new ArrayList<>(); @@ -149,10 +150,10 @@ public void setAnnotation(List annotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -175,10 +176,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -201,10 +202,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -227,10 +228,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -310,6 +311,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "MetadataUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -317,10 +334,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -343,8 +360,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "MetadataUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "MetadataUsage") public Type getEndOwningType() { return endOwningType; } @@ -364,10 +381,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -390,10 +407,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -416,10 +433,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -435,40 +452,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "MetadataUsage") - 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 = "MetadataUsage") - 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; @@ -476,10 +459,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -502,8 +485,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "MetadataUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "MetadataUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -523,10 +506,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -549,10 +532,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -575,10 +558,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -831,10 +814,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -857,10 +840,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -883,10 +866,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -909,8 +892,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MetaclassMetaDef", metaColumn = @javax.persistence.Column(name = "metaclassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "metaclassId", table = "MetadataUsage") + @Any(metaDef = "MetaclassMetaDef", metaColumn = @javax.persistence.Column(name = "metaclass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "metaclass_id", table = "MetadataUsage") public Metaclass getMetaclass() { return metaclass; } @@ -930,8 +913,8 @@ public void setMetaclass(Metaclass metaclass) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MetaclassMetaDef", metaColumn = @javax.persistence.Column(name = "metadataDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "metadataDefinitionId", table = "MetadataUsage") + @Any(metaDef = "MetaclassMetaDef", metaColumn = @javax.persistence.Column(name = "metadataDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "metadataDefinition_id", table = "MetadataUsage") public Metaclass getMetadataDefinition() { return metadataDefinition; } @@ -951,8 +934,8 @@ public void setMetadataDefinition(Metaclass metadataDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "MetadataUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "MetadataUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -965,14 +948,12 @@ public void setMultiplicity(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 = "MetadataUsage") public String getName() { return name; @@ -992,10 +973,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1018,10 +999,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1044,10 +1025,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1070,10 +1051,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1096,10 +1077,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1122,10 +1103,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1148,10 +1129,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1174,10 +1155,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1200,10 +1181,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1226,10 +1207,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1252,10 +1233,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1278,10 +1259,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1304,10 +1285,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1642,10 +1623,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1668,10 +1649,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1694,10 +1675,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1720,10 +1701,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1746,8 +1727,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "MetadataUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "MetadataUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1767,10 +1748,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1793,10 +1774,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1819,10 +1800,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1845,10 +1826,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1871,10 +1852,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1897,10 +1878,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1923,10 +1904,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1949,10 +1930,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1975,10 +1956,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2001,10 +1982,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2025,10 +2006,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2051,10 +2032,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2077,10 +2058,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2103,10 +2084,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2129,10 +2110,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2155,8 +2136,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "MetadataUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "MetadataUsage") public Element getOwner() { return owner; } @@ -2176,8 +2157,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "MetadataUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "MetadataUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2195,8 +2176,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "MetadataUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "MetadataUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2210,19 +2191,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "MetadataUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "MetadataUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2235,8 +2216,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "MetadataUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "MetadataUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2254,8 +2235,8 @@ 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 = "MetadataUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "MetadataUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2275,8 +2256,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "MetadataUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "MetadataUsage") public Type getOwningType() { return owningType; } @@ -2296,8 +2277,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "MetadataUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "MetadataUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2335,8 +2316,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "MetadataUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "MetadataUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2369,6 +2350,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "MetadataUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2376,10 +2375,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2402,10 +2401,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2428,10 +2427,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2454,10 +2453,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2480,10 +2479,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MetadataUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MultiplicityImpl.java b/app/org/omg/sysml/metamodel/impl/MultiplicityImpl.java index 111df9f0..ad775a20 100644 --- a/app/org/omg/sysml/metamodel/impl/MultiplicityImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MultiplicityImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Multiplicity") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MultiplicityImpl extends SysMLTypeImpl implements Multiplicity { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Multiplicity_aliasId", - joinColumns = @JoinColumn(name = "MultiplicityId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Multiplicity_aliasIds", + joinColumns = @JoinColumn(name = "Multiplicity_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Multiplicity") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Multiplicity") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Multiplicity") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "Multiplicity") - 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 = "Multiplicity") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Multiplicity") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Multiplicity") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "Multiplicity") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Multiplicity") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Multiplicity") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Multiplicity") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Multiplicity") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "Multiplicity") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Multiplicity") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Multiplicity") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Multiplicity") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Multiplicity") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Multiplicity") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "Multiplicity") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Multiplicity") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Multiplicity") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Multiplicity") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Multiplicity") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Multiplicity_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl.java b/app/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl.java index 40d52b94..706de511 100644 --- a/app/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "MultiplicityRange") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class MultiplicityRangeImpl extends SysMLTypeImpl implements MultiplicityRange { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "MultiplicityRange_aliasId", - joinColumns = @JoinColumn(name = "MultiplicityRangeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "MultiplicityRange_aliasIds", + joinColumns = @JoinColumn(name = "MultiplicityRange_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_bound", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBound() { if (bound == null) { bound = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBound(List bound) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "MultiplicityRange") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "MultiplicityRange") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "MultiplicityRange") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -359,40 +376,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "MultiplicityRange") - 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 = "MultiplicityRange") - 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; @@ -400,10 +383,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -684,8 +667,8 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "lowerBoundType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lowerBoundId", table = "MultiplicityRange") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "lowerBound_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lowerBound_id", table = "MultiplicityRange") public Expression getLowerBound() { return lowerBound; } @@ -705,10 +688,10 @@ public void setLowerBound(Expression lowerBound) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -731,10 +714,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -757,8 +740,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "MultiplicityRange") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "MultiplicityRange") public Multiplicity getMultiplicity() { return multiplicity; } @@ -771,14 +754,12 @@ public void setMultiplicity(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 = "MultiplicityRange") public String getName() { return name; @@ -798,10 +779,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -824,10 +805,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -850,8 +831,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "MultiplicityRange") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "MultiplicityRange") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -871,10 +852,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -897,10 +878,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -923,10 +904,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -949,10 +930,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -975,10 +956,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1001,10 +982,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1027,10 +1008,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1053,10 +1034,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1079,10 +1060,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1105,10 +1086,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1129,10 +1110,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1155,10 +1136,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1181,10 +1162,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1207,10 +1188,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1233,10 +1214,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1259,8 +1240,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "MultiplicityRange") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "MultiplicityRange") public Element getOwner() { return owner; } @@ -1278,8 +1259,8 @@ 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 = "MultiplicityRange") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "MultiplicityRange") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1293,19 +1274,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "MultiplicityRange") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "MultiplicityRange") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1318,8 +1299,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "MultiplicityRange") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "MultiplicityRange") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1337,8 +1318,8 @@ 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 = "MultiplicityRange") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "MultiplicityRange") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1358,8 +1339,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "MultiplicityRange") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "MultiplicityRange") public Type getOwningType() { return owningType; } @@ -1392,6 +1373,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "MultiplicityRange") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1399,10 +1398,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1425,10 +1424,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "MultiplicityRange_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -1451,8 +1450,8 @@ public void setType(List type) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "upperBoundType"), fetch = FetchType.LAZY) - @JoinColumn(name = "upperBoundId", table = "MultiplicityRange") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "upperBound_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "upperBound_id", table = "MultiplicityRange") public Expression getUpperBound() { return upperBound; } diff --git a/app/org/omg/sysml/metamodel/impl/NamespaceImpl.java b/app/org/omg/sysml/metamodel/impl/NamespaceImpl.java index 8455f317..fc2b155a 100644 --- a/app/org/omg/sysml/metamodel/impl/NamespaceImpl.java +++ b/app/org/omg/sysml/metamodel/impl/NamespaceImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Namespace") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class NamespaceImpl extends SysMLTypeImpl implements Namespace { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Namespace_aliasId", - joinColumns = @JoinColumn(name = "NamespaceId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Namespace_aliasIds", + joinColumns = @JoinColumn(name = "Namespace_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,36 +139,18 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Namespace") - 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 = "Namespace") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Namespace") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -179,10 +162,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -205,10 +188,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -231,10 +214,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -250,14 +233,12 @@ public void setMembership(List membership) { - // @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 = "Namespace") public String getName() { return name; @@ -277,10 +258,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -303,10 +284,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -329,10 +310,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -355,10 +336,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -381,10 +362,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -405,10 +386,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -431,8 +412,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Namespace") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Namespace") public Element getOwner() { return owner; } @@ -446,19 +427,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Namespace") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Namespace") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -471,8 +452,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Namespace") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Namespace") public Namespace getOwningNamespace() { return owningNamespace; } @@ -490,8 +471,8 @@ 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 = "Namespace") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Namespace") public Relationship getOwningRelationship() { return owningRelationship; } @@ -524,6 +505,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Namespace") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -531,10 +530,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Namespace_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/NullExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/NullExpressionImpl.java index 8a5e1f2f..819138ab 100644 --- a/app/org/omg/sysml/metamodel/impl/NullExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/NullExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "NullExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class NullExpressionImpl extends SysMLTypeImpl implements NullExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "NullExpression_aliasId", - joinColumns = @JoinColumn(name = "NullExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "NullExpression_aliasIds", + joinColumns = @JoinColumn(name = "NullExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "NullExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "NullExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "NullExpression") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "NullExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "NullExpression") public Function getFunction() { return function; } @@ -380,40 +397,6 @@ public void setFunction(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 = "NullExpression") - 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 = "NullExpression") - 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; @@ -421,10 +404,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -447,10 +430,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -723,10 +706,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -775,8 +758,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "NullExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "NullExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -789,14 +772,12 @@ public void setMultiplicity(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 = "NullExpression") public String getName() { return name; @@ -816,10 +797,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -842,10 +823,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -868,8 +849,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "NullExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "NullExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -889,10 +870,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1147,10 +1128,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1173,10 +1154,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1199,10 +1180,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1225,10 +1206,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1251,10 +1232,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1277,8 +1258,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "NullExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "NullExpression") public Element getOwner() { return owner; } @@ -1296,8 +1277,8 @@ 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 = "NullExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "NullExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1311,19 +1292,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "NullExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "NullExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1336,8 +1317,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "NullExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "NullExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1355,8 +1336,8 @@ 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 = "NullExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "NullExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1376,8 +1357,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "NullExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "NullExpression") public Type getOwningType() { return owningType; } @@ -1397,10 +1378,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1443,8 +1424,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "NullExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "NullExpression") public Feature getResult() { return result; } @@ -1457,6 +1438,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "NullExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1464,10 +1463,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1490,10 +1489,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "NullExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl.java index d3ec9f07..ff073e73 100644 --- a/app/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ObjectiveMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ObjectiveMembershipImpl extends SysMLTypeImpl implements ObjectiveMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ObjectiveMembership_aliasId", - joinColumns = @JoinColumn(name = "ObjectiveMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ObjectiveMembership_aliasIds", + joinColumns = @JoinColumn(name = "ObjectiveMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "ObjectiveMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "ObjectiveMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "ObjectiveMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "ObjectiveMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "ObjectiveMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "ObjectiveMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "ObjectiveMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "ObjectiveMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "ObjectiveMembership") - 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 = "ObjectiveMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ObjectiveMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ObjectiveMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "ObjectiveMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ObjectiveMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,6 +250,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ObjectiveMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -293,8 +275,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ObjectiveMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ObjectiveMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -307,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ObjectiveMembership") public String getName() { return name; @@ -334,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -360,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -384,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ObjectiveMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ObjectiveMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -398,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ObjectiveMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "ObjectiveMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "ObjectiveMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -417,13 +417,53 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ObjectiveMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ObjectiveMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedObjectiveRequirement") private RequirementUsage ownedObjectiveRequirement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedObjectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedObjectiveRequirementId", table = "ObjectiveMembership") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedObjectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedObjectiveRequirement_id", table = "ObjectiveMembership") public RequirementUsage getOwnedObjectiveRequirement() { return ownedObjectiveRequirement; } @@ -441,10 +481,10 @@ public void setOwnedObjectiveRequirement(RequirementUsage ownedObjectiveRequirem @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -465,10 +505,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -491,8 +531,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ObjectiveMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ObjectiveMembership") public Element getOwner() { return owner; } @@ -512,8 +552,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "ObjectiveMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "ObjectiveMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -527,19 +567,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ObjectiveMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ObjectiveMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -552,8 +592,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ObjectiveMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ObjectiveMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -571,8 +611,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ObjectiveMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ObjectiveMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -590,8 +630,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ObjectiveMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ObjectiveMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -611,8 +651,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ObjectiveMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ObjectiveMembership") public Type getOwningType() { return owningType; } @@ -652,10 +692,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -671,15 +711,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ObjectiveMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -700,10 +758,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -726,10 +784,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ObjectiveMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl.java index a3771d16..e290cfd1 100644 --- a/app/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "OccurrenceDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class OccurrenceDefinitionImpl extends SysMLTypeImpl implements OccurrenceDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "OccurrenceDefinition_aliasId", - joinColumns = @JoinColumn(name = "OccurrenceDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "OccurrenceDefinition_aliasIds", + joinColumns = @JoinColumn(name = "OccurrenceDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "OccurrenceDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "OccurrenceDefinition") - 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 = "OccurrenceDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -495,8 +478,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "OccurrenceDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "OccurrenceDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -516,10 +499,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -542,10 +525,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -568,8 +551,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "OccurrenceDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "OccurrenceDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -582,14 +565,12 @@ public void setMultiplicity(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 = "OccurrenceDefinition") public String getName() { return name; @@ -609,10 +590,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -635,10 +616,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -843,8 +824,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "OccurrenceDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "OccurrenceDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -864,10 +845,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -890,10 +871,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1642,8 +1623,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "OccurrenceDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "OccurrenceDefinition") public Element getOwner() { return owner; } @@ -1657,19 +1638,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "OccurrenceDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "OccurrenceDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1682,8 +1663,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "OccurrenceDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "OccurrenceDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1701,8 +1682,8 @@ 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 = "OccurrenceDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "OccurrenceDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1735,6 +1716,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "OccurrenceDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1742,10 +1741,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1768,10 +1767,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1794,10 +1793,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl.java b/app/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl.java index 1dcf59de..93344763 100644 --- a/app/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "OccurrenceUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class OccurrenceUsageImpl extends SysMLTypeImpl implements OccurrenceUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "OccurrenceUsage_aliasId", - joinColumns = @JoinColumn(name = "OccurrenceUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "OccurrenceUsage_aliasIds", + joinColumns = @JoinColumn(name = "OccurrenceUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "OccurrenceUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "OccurrenceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "OccurrenceUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "OccurrenceUsage") - 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 = "OccurrenceUsage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,8 +435,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "OccurrenceUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "OccurrenceUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -473,10 +456,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -781,10 +764,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -807,10 +790,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -833,8 +816,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "OccurrenceUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "OccurrenceUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -847,14 +830,12 @@ public void setMultiplicity(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 = "OccurrenceUsage") public String getName() { return name; @@ -874,10 +855,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -900,10 +881,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -926,10 +907,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1628,8 +1609,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "OccurrenceUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "OccurrenceUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1649,10 +1630,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1675,10 +1656,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1701,10 +1682,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1907,10 +1888,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2037,8 +2018,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "OccurrenceUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "OccurrenceUsage") public Element getOwner() { return owner; } @@ -2058,8 +2039,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "OccurrenceUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "OccurrenceUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2077,8 +2058,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "OccurrenceUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "OccurrenceUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2092,19 +2073,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "OccurrenceUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "OccurrenceUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2117,8 +2098,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "OccurrenceUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "OccurrenceUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2136,8 +2117,8 @@ 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 = "OccurrenceUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "OccurrenceUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2157,8 +2138,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "OccurrenceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "OccurrenceUsage") public Type getOwningType() { return owningType; } @@ -2178,8 +2159,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "OccurrenceUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "OccurrenceUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2217,8 +2198,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "OccurrenceUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "OccurrenceUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2251,6 +2232,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "OccurrenceUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2258,10 +2257,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2284,10 +2283,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2310,10 +2309,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2336,10 +2335,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OccurrenceUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/OperatorExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/OperatorExpressionImpl.java index 705f2f27..1016e0e1 100644 --- a/app/org/omg/sysml/metamodel/impl/OperatorExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/OperatorExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "OperatorExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class OperatorExpressionImpl extends SysMLTypeImpl implements OperatorExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "OperatorExpression_aliasId", - joinColumns = @JoinColumn(name = "OperatorExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "OperatorExpression_aliasIds", + joinColumns = @JoinColumn(name = "OperatorExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_argument", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getArgument() { if (argument == null) { argument = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setArgument(List argument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "OperatorExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "OperatorExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "OperatorExpression") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "OperatorExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "OperatorExpression") public Function getFunction() { return function; } @@ -406,40 +423,6 @@ public void setFunction(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 = "OperatorExpression") - 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 = "OperatorExpression") - 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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -775,10 +758,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -801,8 +784,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "OperatorExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "OperatorExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -815,14 +798,12 @@ public void setMultiplicity(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 = "OperatorExpression") public String getName() { return name; @@ -842,10 +823,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_operand", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOperand() { if (operand == null) { operand = new ArrayList<>(); @@ -886,10 +867,10 @@ public void setOperator(String operator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -912,10 +893,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -938,8 +919,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "OperatorExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "OperatorExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -959,10 +940,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -985,10 +966,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1011,10 +992,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1037,10 +1018,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1063,10 +1044,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1089,10 +1070,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1115,10 +1096,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1141,10 +1122,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1167,10 +1148,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1193,10 +1174,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1347,8 +1328,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "OperatorExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "OperatorExpression") public Element getOwner() { return owner; } @@ -1366,8 +1347,8 @@ 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 = "OperatorExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "OperatorExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1381,19 +1362,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "OperatorExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "OperatorExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1406,8 +1387,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "OperatorExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "OperatorExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1425,8 +1406,8 @@ 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 = "OperatorExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "OperatorExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1446,8 +1427,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "OperatorExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "OperatorExpression") public Type getOwningType() { return owningType; } @@ -1467,10 +1448,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1513,8 +1494,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "OperatorExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "OperatorExpression") public Feature getResult() { return result; } @@ -1527,6 +1508,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "OperatorExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1534,10 +1533,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1560,10 +1559,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "OperatorExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/OwningMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/OwningMembershipImpl.java new file mode 100644 index 00000000..2c7ddcee --- /dev/null +++ b/app/org/omg/sysml/metamodel/impl/OwningMembershipImpl.java @@ -0,0 +1,706 @@ +/* + * SysML v2 REST/HTTP Pilot Implementation + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC + * + * 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 = "OwningMembershipImpl") +@SecondaryTable(name = "OwningMembership") +@org.hibernate.annotations.Table(appliesTo = "OwningMembership", fetch = FetchMode.SELECT, optional = false) +// @info.archinnov.achilles.annotations.Table(table = "OwningMembership") +@DiscriminatorValue(value = "OwningMembership") +@JsonTypeName(value = "OwningMembership") +@JsonTypeInfo(use = JsonTypeInfo.Id.NAME) +public class OwningMembershipImpl extends SysMLTypeImpl implements OwningMembership { + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @ElementCollection(targetClass = String.class) + @CollectionTable(name = "OwningMembership_aliasIds", + joinColumns = @JoinColumn(name = "OwningMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); + } + return aliasIds; + } + + @JsonSetter + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; + } + + + + // @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 = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_documentation", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + 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("effectiveName") + private String effectiveName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "effectiveName", table = "OwningMembership") + public String getEffectiveName() { + return effectiveName; + } + + @JsonSetter + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; + } + + + + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "OwningMembership") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + + // @info.archinnov.achilles.annotations.Column("memberElement") + private Element memberElement; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "OwningMembership") + public Element getMemberElement() { + return memberElement; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setMemberElement(Element memberElement) { + this.memberElement = memberElement; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "OwningMembership") + public String getMemberElementId() { + return memberElementId; + } + + @JsonSetter + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; + } + + + + // @info.archinnov.achilles.annotations.Column("memberName") + private String memberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberName", table = "OwningMembership") + public String getMemberName() { + return memberName; + } + + @JsonSetter + public void setMemberName(String memberName) { + this.memberName = memberName; + } + + + + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "OwningMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") + private Namespace membershipOwningNamespace; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "OwningMembership") + public Namespace getMembershipOwningNamespace() { + return membershipOwningNamespace; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = NamespaceImpl.class) + public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { + this.membershipOwningNamespace = membershipOwningNamespace; + } + + + + // @info.archinnov.achilles.annotations.Column("name") + private String name; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "name", table = "OwningMembership") + public String getName() { + return name; + } + + @JsonSetter + public void setName(String name) { + this.name = name; + } + + + + // @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 = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_ownedAnnotation", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + 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("ownedElement") + private List ownedElement; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_ownedElement", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + 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.Column("ownedMemberElement") + private Element ownedMemberElement; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "OwningMembership") + public Element getOwnedMemberElement() { + return ownedMemberElement; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setOwnedMemberElement(Element ownedMemberElement) { + this.ownedMemberElement = ownedMemberElement; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "OwningMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "OwningMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "OwningMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") + private List ownedRelatedElement; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_ownedRelatedElement", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + public List getOwnedRelatedElement() { + if (ownedRelatedElement == null) { + ownedRelatedElement = new ArrayList<>(); + } + return ownedRelatedElement; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setOwnedRelatedElement(List ownedRelatedElement) { + this.ownedRelatedElement = ownedRelatedElement; + } + + + + // @info.archinnov.achilles.annotations.Column("ownedRelationship") + private List ownedRelationship; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_ownedRelationship", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + 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("owner") + private Element owner; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + // @javax.persistence.Transient + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "OwningMembership") + 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("owningMembership") + private OwningMembership owningMembership; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "OwningMembership") + public OwningMembership getOwningMembership() { + return owningMembership; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership 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 = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "OwningMembership") + 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("owningRelatedElement") + private Element owningRelatedElement; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "OwningMembership") + public Element getOwningRelatedElement() { + return owningRelatedElement; + } + + @JsonSetter + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setOwningRelatedElement(Element owningRelatedElement) { + this.owningRelatedElement = owningRelatedElement; + } + + + + // @info.archinnov.achilles.annotations.Column("owningRelationship") + private Relationship owningRelationship; + + @JsonGetter + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "OwningMembership") + 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("qualifiedName") + private String qualifiedName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "qualifiedName", table = "OwningMembership") + public String getQualifiedName() { + return qualifiedName; + } + + @JsonSetter + public void setQualifiedName(String qualifiedName) { + this.qualifiedName = qualifiedName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("relatedElement") + private List relatedElement; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_relatedElement", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + public List getRelatedElement() { + if (relatedElement == null) { + relatedElement = new ArrayList<>(); + } + return relatedElement; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setRelatedElement(List relatedElement) { + this.relatedElement = relatedElement; + } + + + + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "OwningMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + + // @info.archinnov.achilles.annotations.Column("source") + private List source; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_source", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + public List getSource() { + if (source == null) { + source = new ArrayList<>(); + } + return source; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setSource(List source) { + this.source = source; + } + + + + // @info.archinnov.achilles.annotations.Column("target") + private List target; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_target", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + public List getTarget() { + if (target == null) { + target = new ArrayList<>(); + } + return target; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = ElementImpl.class) + public void setTarget(List target) { + this.target = target; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("textualRepresentation") + private List textualRepresentation; + + @JsonGetter + @JsonSerialize(contentUsing = DataSerializer.class) + // @javax.persistence.Transient + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) + @JoinTable(name = "OwningMembership_textualRepresentation", + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) + public List getTextualRepresentation() { + if (textualRepresentation == null) { + textualRepresentation = new ArrayList<>(); + } + return textualRepresentation; + } + + @JsonSetter + @JsonDeserialize(contentUsing = DataDeserializer.class, contentAs = TextualRepresentationImpl.class) + public void setTextualRepresentation(List textualRepresentation) { + this.textualRepresentation = textualRepresentation; + } + + + + // @info.archinnov.achilles.annotations.Column("visibility") + // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) + private VisibilityKind visibility; + + @JsonGetter + @javax.persistence.Enumerated(EnumType.STRING) + @javax.persistence.Column(name = "visibility", table = "OwningMembership") + public VisibilityKind getVisibility() { + return visibility; + } + + @JsonSetter + public void setVisibility(VisibilityKind visibility) { + this.visibility = visibility; + } + + + +} diff --git a/app/org/omg/sysml/metamodel/impl/PackageImpl.java b/app/org/omg/sysml/metamodel/impl/PackageImpl.java index 7f1b5042..404308ce 100644 --- a/app/org/omg/sysml/metamodel/impl/PackageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PackageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Package") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PackageImpl extends SysMLTypeImpl implements Package { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Package_aliasId", - joinColumns = @JoinColumn(name = "PackageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Package_aliasIds", + joinColumns = @JoinColumn(name = "Package_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,6 +139,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Package") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("filterCondition") private List filterCondition; @@ -145,10 +162,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_filterCondition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFilterCondition() { if (filterCondition == null) { filterCondition = new ArrayList<>(); @@ -164,40 +181,6 @@ public void setFilterCondition(List filterCondition) { - // @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 = "Package") - 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 = "Package") - 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; @@ -205,10 +188,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -231,10 +214,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -257,10 +240,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -276,14 +259,12 @@ public void setMembership(List membership) { - // @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 = "Package") public String getName() { return name; @@ -303,10 +284,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -329,10 +310,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -355,10 +336,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -381,10 +362,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -407,10 +388,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -431,10 +412,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -457,8 +438,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Package") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Package") public Element getOwner() { return owner; } @@ -472,19 +453,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Package") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Package") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -497,8 +478,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Package") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Package") public Namespace getOwningNamespace() { return owningNamespace; } @@ -516,8 +497,8 @@ 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 = "Package") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Package") public Relationship getOwningRelationship() { return owningRelationship; } @@ -550,6 +531,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Package") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -557,10 +556,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Package_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ParameterMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ParameterMembershipImpl.java index a335e265..82e7dd0a 100644 --- a/app/org/omg/sysml/metamodel/impl/ParameterMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ParameterMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ParameterMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ParameterMembershipImpl extends SysMLTypeImpl implements ParameterMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ParameterMembership_aliasId", - joinColumns = @JoinColumn(name = "ParameterMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ParameterMembership_aliasIds", + joinColumns = @JoinColumn(name = "ParameterMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "ParameterMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "ParameterMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "ParameterMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "ParameterMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "ParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "ParameterMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "ParameterMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "ParameterMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "ParameterMembership") - 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 = "ParameterMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ParameterMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "ParameterMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ParameterMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,21 +250,20 @@ public void setMemberName(String memberName) { - // @info.archinnov.achilles.annotations.Column("memberParameter") - private Feature memberParameter; + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberParameterId", table = "ParameterMembership") - public Feature getMemberParameter() { - return memberParameter; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ParameterMembership") + public String getMemberShortName() { + return memberShortName; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberParameter(Feature memberParameter) { - this.memberParameter = memberParameter; + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; } @@ -312,8 +275,8 @@ public void setMemberParameter(Feature memberParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ParameterMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ParameterMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -326,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ParameterMembership") public String getName() { return name; @@ -353,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -379,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -403,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ParameterMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -417,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ParameterMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "ParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "ParameterMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -436,13 +417,33 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ParameterMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberParameter") private Feature ownedMemberParameter; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberParameterId", table = "ParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberParameter_id", table = "ParameterMembership") public Feature getOwnedMemberParameter() { return ownedMemberParameter; } @@ -455,15 +456,35 @@ public void setOwnedMemberParameter(Feature ownedMemberParameter) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ParameterMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -484,10 +505,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -510,8 +531,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ParameterMembership") public Element getOwner() { return owner; } @@ -531,8 +552,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "ParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "ParameterMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -546,19 +567,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ParameterMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ParameterMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -571,8 +592,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ParameterMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ParameterMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -590,8 +611,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ParameterMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -609,8 +630,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ParameterMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ParameterMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -630,8 +651,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ParameterMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ParameterMembership") public Type getOwningType() { return owningType; } @@ -671,10 +692,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -690,15 +711,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ParameterMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -719,10 +758,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -745,10 +784,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ParameterMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PartDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/PartDefinitionImpl.java index 2324f81e..01803a1b 100644 --- a/app/org/omg/sysml/metamodel/impl/PartDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PartDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "PartDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PartDefinitionImpl extends SysMLTypeImpl implements PartDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PartDefinition_aliasId", - joinColumns = @JoinColumn(name = "PartDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PartDefinition_aliasIds", + joinColumns = @JoinColumn(name = "PartDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "PartDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "PartDefinition") - 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 = "PartDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -495,8 +478,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "PartDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "PartDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -516,10 +499,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -542,10 +525,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -568,8 +551,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PartDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "PartDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -582,14 +565,12 @@ public void setMultiplicity(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 = "PartDefinition") public String getName() { return name; @@ -609,10 +590,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -635,10 +616,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -843,8 +824,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PartDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "PartDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -864,10 +845,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -890,10 +871,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1642,8 +1623,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PartDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PartDefinition") public Element getOwner() { return owner; } @@ -1657,19 +1638,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PartDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PartDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1682,8 +1663,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PartDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PartDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1701,8 +1682,8 @@ 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 = "PartDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PartDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1735,6 +1716,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PartDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1742,10 +1741,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1768,10 +1767,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1794,10 +1793,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PartUsageImpl.java b/app/org/omg/sysml/metamodel/impl/PartUsageImpl.java index ee34992e..efe57a7c 100644 --- a/app/org/omg/sysml/metamodel/impl/PartUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PartUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "PartUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PartUsageImpl extends SysMLTypeImpl implements PartUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PartUsage_aliasId", - joinColumns = @JoinColumn(name = "PartUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PartUsage_aliasIds", + joinColumns = @JoinColumn(name = "PartUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "PartUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "PartUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "PartUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "PartUsage") - 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 = "PartUsage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,8 +435,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "PartUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "PartUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -473,10 +456,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -781,10 +764,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -807,10 +790,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -859,8 +842,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PartUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "PartUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -873,14 +856,12 @@ public void setMultiplicity(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 = "PartUsage") public String getName() { return name; @@ -900,10 +881,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -926,10 +907,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1654,8 +1635,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PartUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "PartUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1675,10 +1656,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1701,10 +1682,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2063,8 +2044,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PartUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PartUsage") public Element getOwner() { return owner; } @@ -2084,8 +2065,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "PartUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "PartUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2103,8 +2084,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "PartUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "PartUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2118,19 +2099,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PartUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PartUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2143,8 +2124,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PartUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PartUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2162,8 +2143,8 @@ 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 = "PartUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PartUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2183,8 +2164,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PartUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "PartUsage") public Type getOwningType() { return owningType; } @@ -2204,8 +2185,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "PartUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "PartUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2225,10 +2206,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2269,8 +2250,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "PartUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "PartUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2303,6 +2284,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PartUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2310,10 +2309,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2336,10 +2335,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2362,10 +2361,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PartUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PerformActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/PerformActionUsageImpl.java index a9c1e4e0..c8ac4928 100644 --- a/app/org/omg/sysml/metamodel/impl/PerformActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PerformActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class PerformActionUsageImpl extends SysMLTypeImpl implements PerformActi @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PerformActionUsage_aliasId", - joinColumns = @JoinColumn(name = "PerformActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PerformActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "PerformActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "PerformActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "PerformActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "PerformActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,8 +383,8 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrenceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "eventOccurrenceId", table = "PerformActionUsage") + @Any(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "eventOccurrence_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "eventOccurrence_id", table = "PerformActionUsage") public OccurrenceUsage getEventOccurrence() { return eventOccurrence; } @@ -387,10 +404,10 @@ public void setEventOccurrence(OccurrenceUsage eventOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -458,40 +475,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "PerformActionUsage") - 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 = "PerformActionUsage") - 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; @@ -499,10 +482,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -525,8 +508,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "PerformActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "PerformActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -546,10 +529,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -572,10 +555,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -598,10 +581,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -854,10 +837,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -880,10 +863,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -906,8 +889,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PerformActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "PerformActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -920,14 +903,12 @@ public void setMultiplicity(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 = "PerformActionUsage") public String getName() { return name; @@ -947,10 +928,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -973,10 +954,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -999,10 +980,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1025,10 +1006,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1051,10 +1032,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1077,10 +1058,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1103,10 +1084,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1129,10 +1110,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1155,10 +1136,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1181,10 +1162,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1207,10 +1188,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1233,10 +1214,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1259,10 +1240,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1285,10 +1266,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1311,10 +1292,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1337,10 +1318,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1363,10 +1344,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1389,10 +1370,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1415,10 +1396,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1441,10 +1422,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1467,10 +1448,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1493,10 +1474,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1519,10 +1500,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1545,10 +1526,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1571,10 +1552,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1597,10 +1578,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1623,10 +1604,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1649,10 +1630,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1675,10 +1656,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1701,8 +1682,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PerformActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "PerformActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1722,10 +1703,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1774,10 +1755,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1800,10 +1781,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1826,10 +1807,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1852,10 +1833,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1878,10 +1859,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1904,10 +1885,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1930,10 +1911,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1956,10 +1937,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2058,10 +2039,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2084,10 +2065,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2110,8 +2091,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PerformActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PerformActionUsage") public Element getOwner() { return owner; } @@ -2131,8 +2112,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "PerformActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "PerformActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2150,8 +2131,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "PerformActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "PerformActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2165,19 +2146,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PerformActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PerformActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2190,8 +2171,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PerformActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PerformActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2209,8 +2190,8 @@ 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 = "PerformActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PerformActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2230,8 +2211,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PerformActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "PerformActionUsage") public Type getOwningType() { return owningType; } @@ -2251,8 +2232,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "PerformActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "PerformActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2272,10 +2253,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2298,8 +2279,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "performedActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "performedActionId", table = "PerformActionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "performedAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "performedAction_id", table = "PerformActionUsage") public ActionUsage getPerformedAction() { return performedAction; } @@ -2337,8 +2318,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "PerformActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "PerformActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2371,6 +2352,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PerformActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2378,10 +2377,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2404,10 +2403,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2430,10 +2429,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2456,10 +2455,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2482,10 +2481,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PerformActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PortConjugationImpl.java b/app/org/omg/sysml/metamodel/impl/PortConjugationImpl.java index 2b5e0c30..a30594ee 100644 --- a/app/org/omg/sysml/metamodel/impl/PortConjugationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PortConjugationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "PortConjugation") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PortConjugationImpl extends SysMLTypeImpl implements PortConjugation { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PortConjugation_aliasId", - joinColumns = @JoinColumn(name = "PortConjugationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PortConjugation_aliasIds", + joinColumns = @JoinColumn(name = "PortConjugation_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,8 +100,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conjugatedPortDefinitionId", table = "PortConjugation") + @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "conjugatedPortDefinition_id", table = "PortConjugation") public ConjugatedPortDefinition getConjugatedPortDefinition() { return conjugatedPortDefinition; } @@ -118,8 +119,8 @@ public void setConjugatedPortDefinition(ConjugatedPortDefinition conjugatedPortD @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conjugatedTypeId", table = "PortConjugation") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "conjugatedType_id", table = "PortConjugation") public Type getConjugatedType() { return conjugatedType; } @@ -139,10 +140,10 @@ public void setConjugatedType(Type conjugatedType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -178,48 +179,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "PortConjugation") - 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 = "PortConjugation") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "PortConjugation") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "PortConjugation") public String getName() { return name; @@ -237,8 +218,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "originalPortDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "originalPortDefinitionId", table = "PortConjugation") + @Any(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "originalPortDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "originalPortDefinition_id", table = "PortConjugation") public PortDefinition getOriginalPortDefinition() { return originalPortDefinition; } @@ -256,8 +237,8 @@ public void setOriginalPortDefinition(PortDefinition originalPortDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "originalTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "originalTypeId", table = "PortConjugation") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "originalType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "originalType_id", table = "PortConjugation") public Type getOriginalType() { return originalType; } @@ -277,10 +258,10 @@ public void setOriginalType(Type originalType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -303,10 +284,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -327,10 +308,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -351,10 +332,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -377,8 +358,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PortConjugation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PortConjugation") public Element getOwner() { return owner; } @@ -392,19 +373,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PortConjugation") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PortConjugation") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -417,8 +398,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PortConjugation") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PortConjugation") public Namespace getOwningNamespace() { return owningNamespace; } @@ -436,8 +417,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "PortConjugation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "PortConjugation") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -455,8 +436,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "PortConjugation") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PortConjugation") public Relationship getOwningRelationship() { return owningRelationship; } @@ -476,8 +457,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PortConjugation") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "PortConjugation") public Type getOwningType() { return owningType; } @@ -517,10 +498,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -536,15 +517,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PortConjugation") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -565,10 +564,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -591,10 +590,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortConjugation_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PortDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/PortDefinitionImpl.java index bef3bf68..26c87d16 100644 --- a/app/org/omg/sysml/metamodel/impl/PortDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PortDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "PortDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PortDefinitionImpl extends SysMLTypeImpl implements PortDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PortDefinition_aliasId", - joinColumns = @JoinColumn(name = "PortDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PortDefinition_aliasIds", + joinColumns = @JoinColumn(name = "PortDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,8 +100,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "conjugatedPortDefinitionId", table = "PortDefinition") + @Any(metaDef = "ConjugatedPortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "conjugatedPortDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "conjugatedPortDefinition_id", table = "PortDefinition") public ConjugatedPortDefinition getConjugatedPortDefinition() { return conjugatedPortDefinition; } @@ -120,10 +121,10 @@ public void setConjugatedPortDefinition(ConjugatedPortDefinition conjugatedPortD @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -146,10 +147,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -172,10 +173,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -211,6 +212,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "PortDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -218,10 +235,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -244,10 +261,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -270,10 +287,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -289,40 +306,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "PortDefinition") - 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 = "PortDefinition") - 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; @@ -330,10 +313,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -356,10 +339,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -382,10 +365,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -408,10 +391,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -516,8 +499,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "PortDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "PortDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -537,10 +520,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -563,10 +546,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -589,8 +572,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PortDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "PortDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -603,14 +586,12 @@ public void setMultiplicity(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 = "PortDefinition") public String getName() { return name; @@ -630,10 +611,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -656,10 +637,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -682,10 +663,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -708,10 +689,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -734,10 +715,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -760,10 +741,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -786,10 +767,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -812,10 +793,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -838,10 +819,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -864,8 +845,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PortDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "PortDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -885,10 +866,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -911,10 +892,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -937,10 +918,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -963,10 +944,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -989,10 +970,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1015,10 +996,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1041,10 +1022,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1067,10 +1048,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1093,10 +1074,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1119,10 +1100,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1145,10 +1126,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1171,10 +1152,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1197,10 +1178,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1223,10 +1204,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1249,10 +1230,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1275,10 +1256,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1301,10 +1282,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1327,10 +1308,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1351,10 +1332,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1377,10 +1358,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1403,10 +1384,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1429,10 +1410,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1455,10 +1436,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1481,10 +1462,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1507,10 +1488,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1533,10 +1514,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1559,10 +1540,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1585,10 +1566,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1611,10 +1592,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1637,10 +1618,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1663,8 +1644,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PortDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PortDefinition") public Element getOwner() { return owner; } @@ -1678,19 +1659,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PortDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PortDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1703,8 +1684,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PortDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PortDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1722,8 +1703,8 @@ 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 = "PortDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PortDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1756,6 +1737,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PortDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1763,10 +1762,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1789,10 +1788,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1815,10 +1814,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1841,10 +1840,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PortUsageImpl.java b/app/org/omg/sysml/metamodel/impl/PortUsageImpl.java index f197e84b..b648da5b 100644 --- a/app/org/omg/sysml/metamodel/impl/PortUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PortUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "PortUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PortUsageImpl extends SysMLTypeImpl implements PortUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PortUsage_aliasId", - joinColumns = @JoinColumn(name = "PortUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PortUsage_aliasIds", + joinColumns = @JoinColumn(name = "PortUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "PortUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "PortUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "PortUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "PortUsage") - 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 = "PortUsage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,8 +435,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "PortUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "PortUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -473,10 +456,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -781,10 +764,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -807,10 +790,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -833,8 +816,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PortUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "PortUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -847,14 +830,12 @@ public void setMultiplicity(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 = "PortUsage") public String getName() { return name; @@ -874,10 +855,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -900,10 +881,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -926,10 +907,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1628,8 +1609,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PortUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "PortUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1649,10 +1630,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1675,10 +1656,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1701,10 +1682,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1907,10 +1888,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2037,8 +2018,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PortUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PortUsage") public Element getOwner() { return owner; } @@ -2058,8 +2039,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "PortUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "PortUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2077,8 +2058,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "PortUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "PortUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2092,19 +2073,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PortUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PortUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2117,8 +2098,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PortUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PortUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2136,8 +2117,8 @@ 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 = "PortUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PortUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2157,8 +2138,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PortUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "PortUsage") public Type getOwningType() { return owningType; } @@ -2178,8 +2159,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "PortUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "PortUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2199,10 +2180,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_portDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPortDefinition() { if (portDefinition == null) { portDefinition = new ArrayList<>(); @@ -2218,27 +2199,6 @@ public void setPortDefinition(List portDefinition) { - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("portOwningUsage") - private Usage portOwningUsage; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "portOwningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portOwningUsageId", table = "PortUsage") - public Usage getPortOwningUsage() { - return portOwningUsage; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = UsageImpl.class) - public void setPortOwningUsage(Usage portOwningUsage) { - this.portOwningUsage = portOwningUsage; - } - - - // @info.archinnov.achilles.annotations.Column("portionKind") // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) private PortionKind portionKind; @@ -2264,8 +2224,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "PortUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "PortUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2298,6 +2258,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PortUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2305,10 +2283,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2331,10 +2309,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2357,10 +2335,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2383,10 +2361,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2409,10 +2387,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PortioningFeatureImpl.java b/app/org/omg/sysml/metamodel/impl/PortioningFeatureImpl.java index 87be4eec..68e4f9ae 100644 --- a/app/org/omg/sysml/metamodel/impl/PortioningFeatureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PortioningFeatureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "PortioningFeature") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PortioningFeatureImpl extends SysMLTypeImpl implements PortioningFeature { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "PortioningFeature_aliasId", - joinColumns = @JoinColumn(name = "PortioningFeatureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "PortioningFeature_aliasIds", + joinColumns = @JoinColumn(name = "PortioningFeature_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "PortioningFeature") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "PortioningFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "PortioningFeature") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "PortioningFeature") - 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 = "PortioningFeature") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "PortioningFeature") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "PortioningFeature") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "PortioningFeature") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "PortioningFeature") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "PortioningFeature") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "PortioningFeature") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "PortioningFeature") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "PortioningFeature") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "PortioningFeature") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "PortioningFeature") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "PortioningFeature") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "PortioningFeature") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "PortioningFeature") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "PortioningFeature") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "PortioningFeature") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "PortioningFeature") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "PortioningFeature") public Type getOwningType() { return owningType; } @@ -1365,6 +1346,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "PortioningFeature") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1372,10 +1371,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1398,10 +1397,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "PortioningFeature_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/PredicateImpl.java b/app/org/omg/sysml/metamodel/impl/PredicateImpl.java index 782cf028..44b04a96 100644 --- a/app/org/omg/sysml/metamodel/impl/PredicateImpl.java +++ b/app/org/omg/sysml/metamodel/impl/PredicateImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Predicate") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class PredicateImpl extends SysMLTypeImpl implements Predicate { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Predicate_aliasId", - joinColumns = @JoinColumn(name = "PredicateId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Predicate_aliasIds", + joinColumns = @JoinColumn(name = "Predicate_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Predicate") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Predicate") - 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 = "Predicate") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -481,10 +464,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -507,10 +490,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -533,8 +516,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Predicate") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Predicate") public Multiplicity getMultiplicity() { return multiplicity; } @@ -547,14 +530,12 @@ public void setMultiplicity(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 = "Predicate") public String getName() { return name; @@ -574,10 +555,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -600,10 +581,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -626,8 +607,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Predicate") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Predicate") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -647,10 +628,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -673,10 +654,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -699,10 +680,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -725,10 +706,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -751,10 +732,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -803,10 +784,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -829,10 +810,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -853,10 +834,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -879,10 +860,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -905,10 +886,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -931,8 +912,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Predicate") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Predicate") public Element getOwner() { return owner; } @@ -946,19 +927,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Predicate") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Predicate") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -971,8 +952,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Predicate") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Predicate") public Namespace getOwningNamespace() { return owningNamespace; } @@ -990,8 +971,8 @@ 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 = "Predicate") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Predicate") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1011,10 +992,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1057,8 +1038,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "Predicate") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "Predicate") public Feature getResult() { return result; } @@ -1071,6 +1052,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Predicate") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1078,10 +1077,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1104,10 +1103,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Predicate_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RedefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/RedefinitionImpl.java index 442cdb0d..84493a59 100644 --- a/app/org/omg/sysml/metamodel/impl/RedefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RedefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Redefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class RedefinitionImpl extends SysMLTypeImpl implements Redefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Redefinition_aliasId", - joinColumns = @JoinColumn(name = "RedefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Redefinition_aliasIds", + joinColumns = @JoinColumn(name = "Redefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,67 +139,47 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("general") - private Type general; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "generalType"), fetch = FetchType.LAZY) - @JoinColumn(name = "generalId", table = "Redefinition") - public Type getGeneral() { - return general; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) - public void setGeneral(Type general) { - this.general = general; - } - - - - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Redefinition") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "Redefinition") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("general") + private Type general; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "Redefinition") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "general_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "general_id", table = "Redefinition") + public Type getGeneral() { + return general; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setGeneral(Type general) { + this.general = general; } - // @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 = "Redefinition") public String getName() { return name; @@ -218,10 +199,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -244,10 +225,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -268,10 +249,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -292,10 +273,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -318,8 +299,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Redefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Redefinition") public Element getOwner() { return owner; } @@ -339,8 +320,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureId", table = "Redefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeature_id", table = "Redefinition") public Feature getOwningFeature() { return owningFeature; } @@ -354,19 +335,19 @@ public void setOwningFeature(Feature owningFeature) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Redefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Redefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -379,8 +360,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Redefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Redefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -398,8 +379,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Redefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Redefinition") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -417,8 +398,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Redefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Redefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -438,8 +419,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Redefinition") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Redefinition") public Type getOwningType() { return owningType; } @@ -477,8 +458,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "redefinedFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "redefinedFeatureId", table = "Redefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "redefinedFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "redefinedFeature_id", table = "Redefinition") public Feature getRedefinedFeature() { return redefinedFeature; } @@ -496,8 +477,8 @@ public void setRedefinedFeature(Feature redefinedFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "redefiningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "redefiningFeatureId", table = "Redefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "redefiningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "redefiningFeature_id", table = "Redefinition") public Feature getRedefiningFeature() { return redefiningFeature; } @@ -517,10 +498,10 @@ public void setRedefiningFeature(Feature redefiningFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -536,15 +517,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Redefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -565,8 +564,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specificType"), fetch = FetchType.LAZY) - @JoinColumn(name = "specificId", table = "Redefinition") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specific_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "specific_id", table = "Redefinition") public Type getSpecific() { return specific; } @@ -584,8 +583,8 @@ public void setSpecific(Type specific) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettedFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subsettedFeatureId", table = "Redefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettedFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subsettedFeature_id", table = "Redefinition") public Feature getSubsettedFeature() { return subsettedFeature; } @@ -603,8 +602,8 @@ public void setSubsettedFeature(Feature subsettedFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettingFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subsettingFeatureId", table = "Redefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettingFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subsettingFeature_id", table = "Redefinition") public Feature getSubsettingFeature() { return subsettingFeature; } @@ -622,10 +621,10 @@ public void setSubsettingFeature(Feature subsettingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -648,10 +647,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Redefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ReferenceUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ReferenceUsageImpl.java index d6a06458..3d73499e 100644 --- a/app/org/omg/sysml/metamodel/impl/ReferenceUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ReferenceUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ReferenceUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ReferenceUsageImpl extends SysMLTypeImpl implements ReferenceUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ReferenceUsage_aliasId", - joinColumns = @JoinColumn(name = "ReferenceUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ReferenceUsage_aliasIds", + joinColumns = @JoinColumn(name = "ReferenceUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ReferenceUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ReferenceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ReferenceUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ReferenceUsage") - 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 = "ReferenceUsage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -744,10 +727,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -770,10 +753,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -796,8 +779,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ReferenceUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ReferenceUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -810,14 +793,12 @@ public void setMultiplicity(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 = "ReferenceUsage") public String getName() { return name; @@ -837,10 +818,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -863,10 +844,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -889,10 +870,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1149,10 +1130,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1175,10 +1156,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1201,10 +1182,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1227,10 +1208,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1253,10 +1234,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1279,10 +1260,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1305,10 +1286,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1331,10 +1312,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1357,10 +1338,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1383,10 +1364,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1409,10 +1390,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1435,10 +1416,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1461,10 +1442,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1487,10 +1468,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1513,10 +1494,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1539,10 +1520,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1565,8 +1546,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ReferenceUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ReferenceUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1586,10 +1567,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1612,10 +1593,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1638,10 +1619,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1664,10 +1645,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1690,10 +1671,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1716,10 +1697,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1742,10 +1723,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1768,10 +1749,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1794,10 +1775,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1820,10 +1801,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1844,10 +1825,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1870,10 +1851,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1896,10 +1877,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1922,10 +1903,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1948,10 +1929,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1974,8 +1955,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ReferenceUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ReferenceUsage") public Element getOwner() { return owner; } @@ -1995,8 +1976,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ReferenceUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ReferenceUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2014,8 +1995,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ReferenceUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ReferenceUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2029,19 +2010,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ReferenceUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ReferenceUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2054,8 +2035,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ReferenceUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ReferenceUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2073,8 +2054,8 @@ 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 = "ReferenceUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ReferenceUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2094,8 +2075,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ReferenceUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ReferenceUsage") public Type getOwningType() { return owningType; } @@ -2115,8 +2096,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ReferenceUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ReferenceUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2149,6 +2130,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ReferenceUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2156,10 +2155,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2182,10 +2181,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2208,10 +2207,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2234,10 +2233,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2260,10 +2259,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReferenceUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RelationshipImpl.java b/app/org/omg/sysml/metamodel/impl/RelationshipImpl.java index 8fceed0a..d5a15960 100644 --- a/app/org/omg/sysml/metamodel/impl/RelationshipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RelationshipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Relationship") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class RelationshipImpl extends SysMLTypeImpl implements Relationship { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Relationship_aliasId", - joinColumns = @JoinColumn(name = "RelationshipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Relationship_aliasIds", + joinColumns = @JoinColumn(name = "Relationship_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,48 +139,28 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Relationship") - 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 = "Relationship") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "Relationship") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @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 = "Relationship") public String getName() { return name; @@ -199,10 +180,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -225,10 +206,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -249,10 +230,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -273,10 +254,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -299,8 +280,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Relationship") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Relationship") public Element getOwner() { return owner; } @@ -314,19 +295,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Relationship") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Relationship") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -339,8 +320,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Relationship") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Relationship") public Namespace getOwningNamespace() { return owningNamespace; } @@ -358,8 +339,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Relationship") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Relationship") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -377,8 +358,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Relationship") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Relationship") public Relationship getOwningRelationship() { return owningRelationship; } @@ -418,10 +399,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -437,15 +418,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Relationship") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -466,10 +465,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -492,10 +491,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Relationship_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl.java index f90fc518..cab52e1a 100644 --- a/app/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "RenderingDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class RenderingDefinitionImpl extends SysMLTypeImpl implements RenderingDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "RenderingDefinition_aliasId", - joinColumns = @JoinColumn(name = "RenderingDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "RenderingDefinition_aliasIds", + joinColumns = @JoinColumn(name = "RenderingDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "RenderingDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "RenderingDefinition") - 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 = "RenderingDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -495,8 +478,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "RenderingDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "RenderingDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -516,10 +499,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -542,10 +525,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -568,8 +551,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "RenderingDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "RenderingDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -582,14 +565,12 @@ public void setMultiplicity(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 = "RenderingDefinition") public String getName() { return name; @@ -609,10 +590,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -635,10 +616,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -843,8 +824,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "RenderingDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "RenderingDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -864,10 +845,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -890,10 +871,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1642,8 +1623,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "RenderingDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "RenderingDefinition") public Element getOwner() { return owner; } @@ -1657,19 +1638,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "RenderingDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "RenderingDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1682,8 +1663,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "RenderingDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "RenderingDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1701,8 +1682,8 @@ 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 = "RenderingDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "RenderingDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1742,10 +1723,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_rendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRendering() { if (rendering == null) { rendering = new ArrayList<>(); @@ -1761,6 +1742,24 @@ public void setRendering(List rendering) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "RenderingDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1768,10 +1767,10 @@ public void setRendering(List rendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1794,10 +1793,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1846,10 +1845,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RenderingUsageImpl.java b/app/org/omg/sysml/metamodel/impl/RenderingUsageImpl.java index 8c95e808..a86739bf 100644 --- a/app/org/omg/sysml/metamodel/impl/RenderingUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RenderingUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "RenderingUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class RenderingUsageImpl extends SysMLTypeImpl implements RenderingUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "RenderingUsage_aliasId", - joinColumns = @JoinColumn(name = "RenderingUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "RenderingUsage_aliasIds", + joinColumns = @JoinColumn(name = "RenderingUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "RenderingUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "RenderingUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "RenderingUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "RenderingUsage") - 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 = "RenderingUsage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,8 +435,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "RenderingUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "RenderingUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -473,10 +456,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -781,10 +764,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -807,10 +790,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -859,8 +842,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "RenderingUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "RenderingUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -873,14 +856,12 @@ public void setMultiplicity(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 = "RenderingUsage") public String getName() { return name; @@ -900,10 +881,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -926,10 +907,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1654,8 +1635,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "RenderingUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "RenderingUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1675,10 +1656,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1701,10 +1682,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2063,8 +2044,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "RenderingUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "RenderingUsage") public Element getOwner() { return owner; } @@ -2084,8 +2065,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "RenderingUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "RenderingUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2103,8 +2084,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "RenderingUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "RenderingUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2118,19 +2099,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "RenderingUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "RenderingUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2143,8 +2124,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "RenderingUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "RenderingUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2162,8 +2143,8 @@ 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 = "RenderingUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "RenderingUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2183,8 +2164,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "RenderingUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "RenderingUsage") public Type getOwningType() { return owningType; } @@ -2204,8 +2185,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "RenderingUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "RenderingUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2225,10 +2206,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2269,8 +2250,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "RenderingUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "RenderingUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2310,8 +2291,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RenderingDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "renderingDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "renderingDefinitionId", table = "RenderingUsage") + @Any(metaDef = "RenderingDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "renderingDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "renderingDefinition_id", table = "RenderingUsage") public RenderingDefinition getRenderingDefinition() { return renderingDefinition; } @@ -2324,6 +2305,24 @@ public void setRenderingDefinition(RenderingDefinition renderingDefinition) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "RenderingUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2331,10 +2330,10 @@ public void setRenderingDefinition(RenderingDefinition renderingDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2357,10 +2356,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2383,10 +2382,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2409,10 +2408,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2435,10 +2434,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RenderingUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl.java index a9d11ee7..9c3ce3c9 100644 --- a/app/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "RequirementConstraintMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class RequirementConstraintMembershipImpl extends SysMLTypeImpl implements RequirementConstraintMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "RequirementConstraintMembership_aliasId", - joinColumns = @JoinColumn(name = "RequirementConstraintMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "RequirementConstraintMembership_aliasIds", + joinColumns = @JoinColumn(name = "RequirementConstraintMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "RequirementConstraintMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "RequirementConstraintMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "RequirementConstraintMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "RequirementConstraintMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "RequirementConstraintMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "RequirementConstraintMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "RequirementConstraintMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "RequirementConstraintMembership") public Type getFeaturingType() { return featuringType; } @@ -196,40 +193,6 @@ public void setFeaturingType(Type featuringType) { - // @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 = "RequirementConstraintMembership") - 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 = "RequirementConstraintMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("kind") // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) private RequirementConstraintKind kind; @@ -253,8 +216,8 @@ public void setKind(RequirementConstraintKind kind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "RequirementConstraintMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "RequirementConstraintMembership") public Element getMemberElement() { return memberElement; } @@ -267,21 +230,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "RequirementConstraintMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "RequirementConstraintMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -304,6 +268,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "RequirementConstraintMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -311,8 +293,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "RequirementConstraintMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "RequirementConstraintMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -325,14 +307,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "RequirementConstraintMembership") public String getName() { return name; @@ -352,10 +332,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -376,8 +356,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConstraintId", table = "RequirementConstraintMembership") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConstraint_id", table = "RequirementConstraintMembership") public ConstraintUsage getOwnedConstraint() { return ownedConstraint; } @@ -397,10 +377,10 @@ public void setOwnedConstraint(ConstraintUsage ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -421,8 +401,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "RequirementConstraintMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "RequirementConstraintMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -435,13 +415,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "RequirementConstraintMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "RequirementConstraintMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "RequirementConstraintMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -454,15 +454,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "RequirementConstraintMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "RequirementConstraintMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -483,10 +523,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -509,8 +549,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "RequirementConstraintMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "RequirementConstraintMembership") public Element getOwner() { return owner; } @@ -530,8 +570,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "RequirementConstraintMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "RequirementConstraintMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -545,19 +585,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "RequirementConstraintMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "RequirementConstraintMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -570,8 +610,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "RequirementConstraintMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "RequirementConstraintMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -589,8 +629,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "RequirementConstraintMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "RequirementConstraintMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -608,8 +648,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "RequirementConstraintMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "RequirementConstraintMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -629,8 +669,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "RequirementConstraintMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "RequirementConstraintMembership") public Type getOwningType() { return owningType; } @@ -670,8 +710,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referencedConstraintId", table = "RequirementConstraintMembership") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referencedConstraint_id", table = "RequirementConstraintMembership") public ConstraintUsage getReferencedConstraint() { return referencedConstraint; } @@ -691,10 +731,10 @@ public void setReferencedConstraint(ConstraintUsage referencedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -710,15 +750,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "RequirementConstraintMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -739,10 +797,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -765,10 +823,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementConstraintMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl.java index c129bcf9..312544a1 100644 --- a/app/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class RequirementDefinitionImpl extends SysMLTypeImpl implements Requirem @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "RequirementDefinition_aliasId", - joinColumns = @JoinColumn(name = "RequirementDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "RequirementDefinition_aliasIds", + joinColumns = @JoinColumn(name = "RequirementDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -242,6 +243,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "RequirementDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -249,10 +266,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -372,40 +389,6 @@ public void setFramedConcern(List framedConcern) { - // @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 = "RequirementDefinition") - 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 = "RequirementDefinition") - 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; @@ -413,10 +396,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -617,8 +600,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "RequirementDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "RequirementDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -638,10 +621,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -664,10 +647,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -690,8 +673,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "RequirementDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "RequirementDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -704,14 +687,12 @@ public void setMultiplicity(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 = "RequirementDefinition") public String getName() { return name; @@ -731,10 +712,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -757,10 +738,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -783,10 +764,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -887,10 +868,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -913,10 +894,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -939,10 +920,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -965,8 +946,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "RequirementDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "RequirementDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -986,10 +967,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1452,10 +1433,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1478,10 +1459,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1504,10 +1485,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1530,10 +1511,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1556,10 +1537,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1582,10 +1563,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1608,10 +1589,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1634,10 +1615,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1660,10 +1641,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1686,10 +1667,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1712,10 +1693,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1738,10 +1719,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1764,8 +1745,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "RequirementDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "RequirementDefinition") public Element getOwner() { return owner; } @@ -1779,19 +1760,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "RequirementDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "RequirementDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1804,8 +1785,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "RequirementDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "RequirementDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1823,8 +1804,8 @@ 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 = "RequirementDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "RequirementDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1844,10 +1825,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1908,10 +1889,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -1934,8 +1915,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "RequirementDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "RequirementDefinition") public Feature getResult() { return result; } @@ -1948,6 +1929,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "RequirementDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -1955,10 +1954,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -1981,10 +1980,10 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -2007,8 +2006,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "RequirementDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "RequirementDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -2031,7 +2030,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "RequirementDefinition_text", - joinColumns = @JoinColumn(name = "RequirementDefinitionId")) + joinColumns = @JoinColumn(name = "RequirementDefinition_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2053,10 +2052,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2079,10 +2078,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2105,10 +2104,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2131,10 +2130,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RequirementUsageImpl.java b/app/org/omg/sysml/metamodel/impl/RequirementUsageImpl.java index 7d120a71..5e303b76 100644 --- a/app/org/omg/sysml/metamodel/impl/RequirementUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RequirementUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class RequirementUsageImpl extends SysMLTypeImpl implements RequirementUs @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "RequirementUsage_aliasId", - joinColumns = @JoinColumn(name = "RequirementUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "RequirementUsage_aliasIds", + joinColumns = @JoinColumn(name = "RequirementUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -203,8 +204,8 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "constraintDefinitionId", table = "RequirementUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "constraintDefinition_id", table = "RequirementUsage") public Predicate getConstraintDefinition() { return constraintDefinition; } @@ -224,10 +225,10 @@ public void setConstraintDefinition(Predicate constraintDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -250,10 +251,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -276,10 +277,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -320,10 +321,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -359,6 +360,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "RequirementUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -366,10 +383,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "RequirementUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "RequirementUsage") public Type getEndOwningType() { return endOwningType; } @@ -413,10 +430,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -465,10 +482,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -491,10 +508,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -517,8 +534,8 @@ public void setFramedConcern(List framedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "RequirementUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "RequirementUsage") public Function getFunction() { return function; } @@ -531,40 +548,6 @@ public void setFunction(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 = "RequirementUsage") - 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 = "RequirementUsage") - 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; @@ -572,10 +555,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -598,8 +581,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "RequirementUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "RequirementUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -619,10 +602,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -645,10 +628,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -671,10 +654,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -945,10 +928,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -971,10 +954,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -997,8 +980,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "RequirementUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "RequirementUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1011,14 +994,12 @@ public void setMultiplicity(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 = "RequirementUsage") public String getName() { return name; @@ -1038,10 +1019,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1454,10 +1435,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1480,10 +1461,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1506,10 +1487,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1532,10 +1513,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1558,10 +1539,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1584,10 +1565,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1610,10 +1591,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1636,10 +1617,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1662,10 +1643,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1688,10 +1669,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1714,10 +1695,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1740,10 +1721,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1766,10 +1747,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1792,8 +1773,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "RequirementUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "RequirementUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1813,10 +1794,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1839,10 +1820,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1865,10 +1846,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1891,10 +1872,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1917,10 +1898,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1943,10 +1924,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1969,10 +1950,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1995,10 +1976,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2021,10 +2002,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2047,10 +2028,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2071,10 +2052,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2097,10 +2078,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2123,10 +2104,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2149,10 +2130,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2175,10 +2156,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2201,8 +2182,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "RequirementUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "RequirementUsage") public Element getOwner() { return owner; } @@ -2222,8 +2203,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "RequirementUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "RequirementUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2241,8 +2222,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "RequirementUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "RequirementUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2256,19 +2237,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "RequirementUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "RequirementUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2281,8 +2262,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "RequirementUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "RequirementUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2300,8 +2281,8 @@ 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 = "RequirementUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "RequirementUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2321,8 +2302,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "RequirementUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "RequirementUsage") public Type getOwningType() { return owningType; } @@ -2342,8 +2323,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "RequirementUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "RequirementUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2363,10 +2344,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2407,8 +2388,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "RequirementUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "RequirementUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2428,8 +2409,8 @@ public void setPortioningFeature(PortioningFeature portioningFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "RequirementUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "RequirementUsage") public Predicate getPredicate() { return predicate; } @@ -2487,10 +2468,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -2513,8 +2494,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "requirementDefinitionId", table = "RequirementUsage") + @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "requirementDefinition_id", table = "RequirementUsage") public RequirementDefinition getRequirementDefinition() { return requirementDefinition; } @@ -2534,8 +2515,8 @@ public void setRequirementDefinition(RequirementDefinition requirementDefinition @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "RequirementUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "RequirementUsage") public Feature getResult() { return result; } @@ -2548,6 +2529,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "RequirementUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -2555,10 +2554,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -2581,8 +2580,8 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "RequirementUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "RequirementUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2605,7 +2604,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "RequirementUsage_text", - joinColumns = @JoinColumn(name = "RequirementUsageId")) + joinColumns = @JoinColumn(name = "RequirementUsage_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2627,10 +2626,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2653,10 +2652,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2679,10 +2678,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2705,10 +2704,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2731,10 +2730,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl.java index 7765f8a7..b1818408 100644 --- a/app/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "RequirementVerificationMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class RequirementVerificationMembershipImpl extends SysMLTypeImpl implements RequirementVerificationMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "RequirementVerificationMembership_aliasId", - joinColumns = @JoinColumn(name = "RequirementVerificationMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "RequirementVerificationMembership_aliasIds", + joinColumns = @JoinColumn(name = "RequirementVerificationMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "RequirementVerificationMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "RequirementVerificationMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "RequirementVerificationMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "RequirementVerificationMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "RequirementVerificationMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "RequirementVerificationMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "RequirementVerificationMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "RequirementVerificationMembership") public Type getFeaturingType() { return featuringType; } @@ -196,40 +193,6 @@ public void setFeaturingType(Type featuringType) { - // @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 = "RequirementVerificationMembership") - 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 = "RequirementVerificationMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("kind") // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) private RequirementConstraintKind kind; @@ -253,8 +216,8 @@ public void setKind(RequirementConstraintKind kind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "RequirementVerificationMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "RequirementVerificationMembership") public Element getMemberElement() { return memberElement; } @@ -267,21 +230,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "RequirementVerificationMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "RequirementVerificationMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -304,6 +268,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "RequirementVerificationMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -311,8 +293,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "RequirementVerificationMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "RequirementVerificationMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -325,14 +307,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "RequirementVerificationMembership") public String getName() { return name; @@ -352,10 +332,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -376,8 +356,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConstraintId", table = "RequirementVerificationMembership") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConstraint_id", table = "RequirementVerificationMembership") public ConstraintUsage getOwnedConstraint() { return ownedConstraint; } @@ -397,10 +377,10 @@ public void setOwnedConstraint(ConstraintUsage ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -421,8 +401,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "RequirementVerificationMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "RequirementVerificationMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -435,13 +415,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "RequirementVerificationMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "RequirementVerificationMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "RequirementVerificationMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -454,15 +454,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "RequirementVerificationMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "RequirementVerificationMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -483,10 +523,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -507,8 +547,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedRequirementId", table = "RequirementVerificationMembership") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedRequirement_id", table = "RequirementVerificationMembership") public RequirementUsage getOwnedRequirement() { return ownedRequirement; } @@ -528,8 +568,8 @@ public void setOwnedRequirement(RequirementUsage ownedRequirement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "RequirementVerificationMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "RequirementVerificationMembership") public Element getOwner() { return owner; } @@ -549,8 +589,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "RequirementVerificationMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "RequirementVerificationMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -564,19 +604,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "RequirementVerificationMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "RequirementVerificationMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -589,8 +629,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "RequirementVerificationMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "RequirementVerificationMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -608,8 +648,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "RequirementVerificationMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "RequirementVerificationMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -627,8 +667,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "RequirementVerificationMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "RequirementVerificationMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -648,8 +688,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "RequirementVerificationMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "RequirementVerificationMembership") public Type getOwningType() { return owningType; } @@ -689,8 +729,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referencedConstraintId", table = "RequirementVerificationMembership") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referencedConstraint_id", table = "RequirementVerificationMembership") public ConstraintUsage getReferencedConstraint() { return referencedConstraint; } @@ -710,10 +750,10 @@ public void setReferencedConstraint(ConstraintUsage referencedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -729,15 +769,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "RequirementVerificationMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -758,10 +816,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -784,10 +842,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "RequirementVerificationMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -810,8 +868,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "verifiedRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "verifiedRequirementId", table = "RequirementVerificationMembership") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "verifiedRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "verifiedRequirement_id", table = "RequirementVerificationMembership") public RequirementUsage getVerifiedRequirement() { return verifiedRequirement; } diff --git a/app/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl.java index 0731e9b2..7bb2b48a 100644 --- a/app/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ResultExpressionMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ResultExpressionMembershipImpl extends SysMLTypeImpl implements ResultExpressionMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ResultExpressionMembership_aliasId", - joinColumns = @JoinColumn(name = "ResultExpressionMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ResultExpressionMembership_aliasIds", + joinColumns = @JoinColumn(name = "ResultExpressionMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "ResultExpressionMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "ResultExpressionMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "ResultExpressionMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "ResultExpressionMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "ResultExpressionMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "ResultExpressionMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "ResultExpressionMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "ResultExpressionMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "ResultExpressionMembership") - 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 = "ResultExpressionMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ResultExpressionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ResultExpressionMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "ResultExpressionMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ResultExpressionMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,6 +250,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ResultExpressionMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -293,8 +275,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ResultExpressionMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ResultExpressionMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -307,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ResultExpressionMembership") public String getName() { return name; @@ -334,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -360,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -384,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ResultExpressionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ResultExpressionMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -398,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ResultExpressionMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "ResultExpressionMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "ResultExpressionMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -417,15 +417,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ResultExpressionMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ResultExpressionMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -446,10 +486,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -470,8 +510,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "ownedResultExpressionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedResultExpressionId", table = "ResultExpressionMembership") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "ownedResultExpression_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedResultExpression_id", table = "ResultExpressionMembership") public Expression getOwnedResultExpression() { return ownedResultExpression; } @@ -491,8 +531,8 @@ public void setOwnedResultExpression(Expression ownedResultExpression) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ResultExpressionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ResultExpressionMembership") public Element getOwner() { return owner; } @@ -512,8 +552,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "ResultExpressionMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "ResultExpressionMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -527,19 +567,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ResultExpressionMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ResultExpressionMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -552,8 +592,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ResultExpressionMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ResultExpressionMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -571,8 +611,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ResultExpressionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ResultExpressionMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -590,8 +630,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ResultExpressionMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ResultExpressionMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -611,8 +651,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ResultExpressionMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ResultExpressionMembership") public Type getOwningType() { return owningType; } @@ -652,10 +692,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -671,15 +711,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ResultExpressionMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -700,10 +758,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -726,10 +784,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ResultExpressionMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl.java index 61ccc54b..4833074c 100644 --- a/app/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ReturnParameterMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ReturnParameterMembershipImpl extends SysMLTypeImpl implements ReturnParameterMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ReturnParameterMembership_aliasId", - joinColumns = @JoinColumn(name = "ReturnParameterMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ReturnParameterMembership_aliasIds", + joinColumns = @JoinColumn(name = "ReturnParameterMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "ReturnParameterMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "ReturnParameterMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "ReturnParameterMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "ReturnParameterMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "ReturnParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "ReturnParameterMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "ReturnParameterMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "ReturnParameterMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "ReturnParameterMembership") - 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 = "ReturnParameterMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ReturnParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ReturnParameterMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "ReturnParameterMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ReturnParameterMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,21 +250,20 @@ public void setMemberName(String memberName) { - // @info.archinnov.achilles.annotations.Column("memberParameter") - private Feature memberParameter; + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberParameterId", table = "ReturnParameterMembership") - public Feature getMemberParameter() { - return memberParameter; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ReturnParameterMembership") + public String getMemberShortName() { + return memberShortName; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberParameter(Feature memberParameter) { - this.memberParameter = memberParameter; + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; } @@ -312,8 +275,8 @@ public void setMemberParameter(Feature memberParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ReturnParameterMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ReturnParameterMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -326,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ReturnParameterMembership") public String getName() { return name; @@ -353,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -379,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -403,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ReturnParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ReturnParameterMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -417,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ReturnParameterMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "ReturnParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "ReturnParameterMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -436,13 +417,33 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ReturnParameterMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberParameter") private Feature ownedMemberParameter; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberParameterId", table = "ReturnParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberParameter_id", table = "ReturnParameterMembership") public Feature getOwnedMemberParameter() { return ownedMemberParameter; } @@ -455,15 +456,35 @@ public void setOwnedMemberParameter(Feature ownedMemberParameter) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ReturnParameterMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -484,10 +505,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -510,8 +531,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ReturnParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ReturnParameterMembership") public Element getOwner() { return owner; } @@ -531,8 +552,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "ReturnParameterMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "ReturnParameterMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -546,19 +567,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ReturnParameterMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ReturnParameterMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -571,8 +592,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ReturnParameterMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ReturnParameterMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -590,8 +611,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ReturnParameterMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ReturnParameterMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -609,8 +630,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ReturnParameterMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ReturnParameterMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -630,8 +651,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ReturnParameterMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ReturnParameterMembership") public Type getOwningType() { return owningType; } @@ -671,10 +692,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -690,15 +711,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ReturnParameterMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -719,10 +758,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -745,10 +784,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ReturnParameterMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl.java b/app/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl.java index 34778804..0b9ffc0f 100644 --- a/app/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class SatisfyRequirementUsageImpl extends SysMLTypeImpl implements Satisf @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SatisfyRequirementUsage_aliasId", - joinColumns = @JoinColumn(name = "SatisfyRequirementUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SatisfyRequirementUsage_aliasIds", + joinColumns = @JoinColumn(name = "SatisfyRequirementUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,8 +126,8 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "assertedConstraintType"), fetch = FetchType.LAZY) - @JoinColumn(name = "assertedConstraintId", table = "SatisfyRequirementUsage") + @Any(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "assertedConstraint_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "assertedConstraint_id", table = "SatisfyRequirementUsage") public ConstraintUsage getAssertedConstraint() { return assertedConstraint; } @@ -146,10 +147,10 @@ public void setAssertedConstraint(ConstraintUsage assertedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -172,10 +173,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -198,10 +199,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -224,8 +225,8 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "constraintDefinitionId", table = "SatisfyRequirementUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "constraintDefinition_id", table = "SatisfyRequirementUsage") public Predicate getConstraintDefinition() { return constraintDefinition; } @@ -245,10 +246,10 @@ public void setConstraintDefinition(Predicate constraintDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -297,10 +298,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -341,10 +342,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -380,6 +381,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SatisfyRequirementUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -387,10 +404,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -413,8 +430,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SatisfyRequirementUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SatisfyRequirementUsage") public Type getEndOwningType() { return endOwningType; } @@ -434,10 +451,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -460,10 +477,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -486,10 +503,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -512,10 +529,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -538,8 +555,8 @@ public void setFramedConcern(List framedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "SatisfyRequirementUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "SatisfyRequirementUsage") public Function getFunction() { return function; } @@ -552,40 +569,6 @@ public void setFunction(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 = "SatisfyRequirementUsage") - 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 = "SatisfyRequirementUsage") - 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; @@ -593,10 +576,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -619,8 +602,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "SatisfyRequirementUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "SatisfyRequirementUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -640,10 +623,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -666,10 +649,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -692,10 +675,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -982,10 +965,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -1008,10 +991,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1034,8 +1017,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SatisfyRequirementUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SatisfyRequirementUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1048,14 +1031,12 @@ public void setMultiplicity(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 = "SatisfyRequirementUsage") public String getName() { return name; @@ -1075,10 +1056,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1101,10 +1082,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1127,10 +1108,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1153,10 +1134,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1179,10 +1160,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1205,10 +1186,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1231,10 +1212,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1257,10 +1238,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1283,10 +1264,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1309,10 +1290,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1335,10 +1316,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1361,10 +1342,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1387,10 +1368,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1413,10 +1394,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1439,10 +1420,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1465,10 +1446,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1491,10 +1472,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1517,10 +1498,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1543,10 +1524,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1569,10 +1550,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1595,10 +1576,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1621,10 +1602,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1647,10 +1628,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1673,10 +1654,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1699,10 +1680,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1725,10 +1706,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1751,10 +1732,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1777,10 +1758,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1803,10 +1784,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1829,8 +1810,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SatisfyRequirementUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SatisfyRequirementUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1850,10 +1831,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1876,10 +1857,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1902,10 +1883,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1928,10 +1909,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1954,10 +1935,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2058,10 +2039,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2084,10 +2065,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2108,10 +2089,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2134,10 +2115,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2160,10 +2141,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2186,10 +2167,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2212,10 +2193,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2238,8 +2219,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SatisfyRequirementUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SatisfyRequirementUsage") public Element getOwner() { return owner; } @@ -2259,8 +2240,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "SatisfyRequirementUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "SatisfyRequirementUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2278,8 +2259,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "SatisfyRequirementUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SatisfyRequirementUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2293,19 +2274,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SatisfyRequirementUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SatisfyRequirementUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2318,8 +2299,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SatisfyRequirementUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SatisfyRequirementUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2337,8 +2318,8 @@ 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 = "SatisfyRequirementUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SatisfyRequirementUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2358,8 +2339,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SatisfyRequirementUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SatisfyRequirementUsage") public Type getOwningType() { return owningType; } @@ -2379,8 +2360,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "SatisfyRequirementUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "SatisfyRequirementUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2400,10 +2381,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2444,8 +2425,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "SatisfyRequirementUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "SatisfyRequirementUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2465,8 +2446,8 @@ public void setPortioningFeature(PortioningFeature portioningFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "SatisfyRequirementUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "SatisfyRequirementUsage") public Predicate getPredicate() { return predicate; } @@ -2524,10 +2505,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -2550,8 +2531,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "requirementDefinitionId", table = "SatisfyRequirementUsage") + @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "requirementDefinition_id", table = "SatisfyRequirementUsage") public RequirementDefinition getRequirementDefinition() { return requirementDefinition; } @@ -2571,8 +2552,8 @@ public void setRequirementDefinition(RequirementDefinition requirementDefinition @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "SatisfyRequirementUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "SatisfyRequirementUsage") public Feature getResult() { return result; } @@ -2592,8 +2573,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "satisfiedRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "satisfiedRequirementId", table = "SatisfyRequirementUsage") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "satisfiedRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "satisfiedRequirement_id", table = "SatisfyRequirementUsage") public RequirementUsage getSatisfiedRequirement() { return satisfiedRequirement; } @@ -2613,8 +2594,8 @@ public void setSatisfiedRequirement(RequirementUsage satisfiedRequirement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "satisfyingFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "satisfyingFeatureId", table = "SatisfyRequirementUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "satisfyingFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "satisfyingFeature_id", table = "SatisfyRequirementUsage") public Feature getSatisfyingFeature() { return satisfyingFeature; } @@ -2627,6 +2608,24 @@ public void setSatisfyingFeature(Feature satisfyingFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SatisfyRequirementUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -2634,10 +2633,10 @@ public void setSatisfyingFeature(Feature satisfyingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -2660,8 +2659,8 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "SatisfyRequirementUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "SatisfyRequirementUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2684,7 +2683,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "SatisfyRequirementUsage_text", - joinColumns = @JoinColumn(name = "SatisfyRequirementUsageId")) + joinColumns = @JoinColumn(name = "SatisfyRequirementUsage_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2706,10 +2705,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2732,10 +2731,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2758,10 +2757,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2784,10 +2783,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2810,10 +2809,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SatisfyRequirementUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java index 0e9c6385..72e78811 100644 --- a/app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SelectExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "SelectExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SelectExpressionImpl extends SysMLTypeImpl implements SelectExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SelectExpression_aliasId", - joinColumns = @JoinColumn(name = "SelectExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SelectExpression_aliasIds", + joinColumns = @JoinColumn(name = "SelectExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_argument", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getArgument() { if (argument == null) { argument = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setArgument(List argument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SelectExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SelectExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SelectExpression") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "SelectExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "SelectExpression") public Function getFunction() { return function; } @@ -406,40 +423,6 @@ public void setFunction(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 = "SelectExpression") - 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 = "SelectExpression") - 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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -749,10 +732,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -775,10 +758,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -801,8 +784,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SelectExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SelectExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -815,14 +798,12 @@ public void setMultiplicity(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 = "SelectExpression") public String getName() { return name; @@ -842,10 +823,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_operand", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOperand() { if (operand == null) { operand = new ArrayList<>(); @@ -886,10 +867,10 @@ public void setOperator(String operator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -912,10 +893,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -938,8 +919,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SelectExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SelectExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -959,10 +940,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -985,10 +966,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1011,10 +992,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1037,10 +1018,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1063,10 +1044,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1089,10 +1070,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1115,10 +1096,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1141,10 +1122,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1167,10 +1148,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1193,10 +1174,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1347,8 +1328,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SelectExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SelectExpression") public Element getOwner() { return owner; } @@ -1366,8 +1347,8 @@ 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 = "SelectExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SelectExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1381,19 +1362,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SelectExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SelectExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1406,8 +1387,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SelectExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SelectExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1425,8 +1406,8 @@ 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 = "SelectExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SelectExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1446,8 +1427,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SelectExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SelectExpression") public Type getOwningType() { return owningType; } @@ -1467,10 +1448,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1513,8 +1494,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "SelectExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "SelectExpression") public Feature getResult() { return result; } @@ -1527,6 +1508,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SelectExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1534,10 +1533,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1560,10 +1559,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SelectExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SendActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/SendActionUsageImpl.java index 90a1578e..0363c6c0 100644 --- a/app/org/omg/sysml/metamodel/impl/SendActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SendActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class SendActionUsageImpl extends SysMLTypeImpl implements SendActionUsag @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SendActionUsage_aliasId", - joinColumns = @JoinColumn(name = "SendActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SendActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "SendActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SendActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SendActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SendActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "SendActionUsage") - 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 = "SendActionUsage") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,8 +487,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "SendActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "SendActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -525,10 +508,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -577,10 +560,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SendActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SendActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "SendActionUsage") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SendActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SendActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SendActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SendActionUsage") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "SendActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "SendActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "SendActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SendActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SendActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SendActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SendActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SendActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "SendActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SendActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SendActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SendActionUsage") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "SendActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "SendActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2277,8 +2258,8 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "payloadArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "payloadArgumentId", table = "SendActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "payloadArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "payloadArgument_id", table = "SendActionUsage") public Expression getPayloadArgument() { return payloadArgument; } @@ -2316,8 +2297,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "SendActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "SendActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2357,8 +2338,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "receiverArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "receiverArgumentId", table = "SendActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "receiverArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "receiverArgument_id", table = "SendActionUsage") public Expression getReceiverArgument() { return receiverArgument; } @@ -2371,6 +2352,24 @@ public void setReceiverArgument(Expression receiverArgument) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SendActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2378,10 +2377,10 @@ public void setReceiverArgument(Expression receiverArgument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2404,10 +2403,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2430,10 +2429,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2456,10 +2455,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2482,10 +2481,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SendActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SourceEndImpl.java b/app/org/omg/sysml/metamodel/impl/SourceEndImpl.java index ae3efe91..2ad441ff 100644 --- a/app/org/omg/sysml/metamodel/impl/SourceEndImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SourceEndImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "SourceEnd") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SourceEndImpl extends SysMLTypeImpl implements SourceEnd { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SourceEnd_aliasId", - joinColumns = @JoinColumn(name = "SourceEndId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SourceEnd_aliasIds", + joinColumns = @JoinColumn(name = "SourceEnd_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SourceEnd") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SourceEnd") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SourceEnd") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "SourceEnd") - 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 = "SourceEnd") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SourceEnd") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SourceEnd") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "SourceEnd") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SourceEnd") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SourceEnd") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SourceEnd") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SourceEnd") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "SourceEnd") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SourceEnd") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SourceEnd") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SourceEnd") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SourceEnd") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SourceEnd") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "SourceEnd") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SourceEnd") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SourceEnd") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SourceEnd") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SourceEnd") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SourceEnd_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SpecializationImpl.java b/app/org/omg/sysml/metamodel/impl/SpecializationImpl.java index d280a764..a6793f91 100644 --- a/app/org/omg/sysml/metamodel/impl/SpecializationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SpecializationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Specialization") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SpecializationImpl extends SysMLTypeImpl implements Specialization { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Specialization_aliasId", - joinColumns = @JoinColumn(name = "SpecializationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Specialization_aliasIds", + joinColumns = @JoinColumn(name = "Specialization_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,67 +139,47 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("general") - private Type general; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "generalType"), fetch = FetchType.LAZY) - @JoinColumn(name = "generalId", table = "Specialization") - public Type getGeneral() { - return general; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) - public void setGeneral(Type general) { - this.general = general; - } - - - - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Specialization") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "Specialization") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("general") + private Type general; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "Specialization") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "general_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "general_id", table = "Specialization") + public Type getGeneral() { + return general; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setGeneral(Type general) { + this.general = general; } - // @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 = "Specialization") public String getName() { return name; @@ -218,10 +199,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -244,10 +225,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -268,10 +249,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -292,10 +273,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -318,8 +299,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Specialization") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Specialization") public Element getOwner() { return owner; } @@ -333,19 +314,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Specialization") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Specialization") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -358,8 +339,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Specialization") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Specialization") public Namespace getOwningNamespace() { return owningNamespace; } @@ -377,8 +358,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Specialization") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Specialization") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -396,8 +377,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Specialization") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Specialization") public Relationship getOwningRelationship() { return owningRelationship; } @@ -417,8 +398,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Specialization") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Specialization") public Type getOwningType() { return owningType; } @@ -458,10 +439,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -477,15 +458,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Specialization") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -506,8 +505,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specificType"), fetch = FetchType.LAZY) - @JoinColumn(name = "specificId", table = "Specialization") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specific_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "specific_id", table = "Specialization") public Type getSpecific() { return specific; } @@ -525,10 +524,10 @@ public void setSpecific(Type specific) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -551,10 +550,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Specialization_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl.java index b88081ba..112c2503 100644 --- a/app/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "StakeholderMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class StakeholderMembershipImpl extends SysMLTypeImpl implements StakeholderMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "StakeholderMembership_aliasId", - joinColumns = @JoinColumn(name = "StakeholderMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "StakeholderMembership_aliasIds", + joinColumns = @JoinColumn(name = "StakeholderMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "StakeholderMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "StakeholderMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "StakeholderMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "StakeholderMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "StakeholderMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "StakeholderMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "StakeholderMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "StakeholderMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "StakeholderMembership") - 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 = "StakeholderMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "StakeholderMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "StakeholderMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "StakeholderMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "StakeholderMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,21 +250,20 @@ public void setMemberName(String memberName) { - // @info.archinnov.achilles.annotations.Column("memberParameter") - private Feature memberParameter; + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberParameterId", table = "StakeholderMembership") - public Feature getMemberParameter() { - return memberParameter; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "StakeholderMembership") + public String getMemberShortName() { + return memberShortName; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberParameter(Feature memberParameter) { - this.memberParameter = memberParameter; + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; } @@ -312,8 +275,8 @@ public void setMemberParameter(Feature memberParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "StakeholderMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "StakeholderMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -326,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "StakeholderMembership") public String getName() { return name; @@ -353,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -379,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -403,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "StakeholderMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "StakeholderMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -417,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "StakeholderMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "StakeholderMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "StakeholderMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -436,13 +417,33 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "StakeholderMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberParameter") private Feature ownedMemberParameter; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberParameterId", table = "StakeholderMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberParameter_id", table = "StakeholderMembership") public Feature getOwnedMemberParameter() { return ownedMemberParameter; } @@ -455,15 +456,35 @@ public void setOwnedMemberParameter(Feature ownedMemberParameter) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "StakeholderMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -484,10 +505,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -508,8 +529,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedStakeholderParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedStakeholderParameterId", table = "StakeholderMembership") + @Any(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedStakeholderParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedStakeholderParameter_id", table = "StakeholderMembership") public PartUsage getOwnedStakeholderParameter() { return ownedStakeholderParameter; } @@ -529,8 +550,8 @@ public void setOwnedStakeholderParameter(PartUsage ownedStakeholderParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "StakeholderMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "StakeholderMembership") public Element getOwner() { return owner; } @@ -550,8 +571,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "StakeholderMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "StakeholderMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -565,19 +586,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "StakeholderMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "StakeholderMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -590,8 +611,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "StakeholderMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "StakeholderMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -609,8 +630,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "StakeholderMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "StakeholderMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -628,8 +649,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "StakeholderMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "StakeholderMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -649,8 +670,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "StakeholderMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "StakeholderMembership") public Type getOwningType() { return owningType; } @@ -690,10 +711,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -709,15 +730,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "StakeholderMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -738,10 +777,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -764,10 +803,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StakeholderMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/StateDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/StateDefinitionImpl.java index b56bad5e..510265f2 100644 --- a/app/org/omg/sysml/metamodel/impl/StateDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/StateDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class StateDefinitionImpl extends SysMLTypeImpl implements StateDefinitio @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setAction(List action) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "StateDefinition_aliasId", - joinColumns = @JoinColumn(name = "StateDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "StateDefinition_aliasIds", + joinColumns = @JoinColumn(name = "StateDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -177,8 +178,8 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "doActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "doActionId", table = "StateDefinition") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "doAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "doAction_id", table = "StateDefinition") public ActionUsage getDoAction() { return doAction; } @@ -198,10 +199,10 @@ public void setDoAction(ActionUsage doAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -237,6 +238,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "StateDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -244,10 +261,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -270,8 +287,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "entryActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "entryActionId", table = "StateDefinition") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "entryAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "entryAction_id", table = "StateDefinition") public ActionUsage getEntryAction() { return entryAction; } @@ -291,8 +308,8 @@ public void setEntryAction(ActionUsage entryAction) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exitActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "exitActionId", table = "StateDefinition") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exitAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "exitAction_id", table = "StateDefinition") public ActionUsage getExitAction() { return exitAction; } @@ -312,10 +329,10 @@ public void setExitAction(ActionUsage exitAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -338,10 +355,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -357,40 +374,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "StateDefinition") - 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 = "StateDefinition") - 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; @@ -398,10 +381,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -424,10 +407,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -450,10 +433,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -476,10 +459,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -600,8 +583,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "StateDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "StateDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -621,10 +604,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -647,10 +630,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -673,8 +656,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "StateDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "StateDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -687,14 +670,12 @@ public void setMultiplicity(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 = "StateDefinition") public String getName() { return name; @@ -714,10 +695,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -740,10 +721,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -766,10 +747,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -792,10 +773,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -818,10 +799,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -844,10 +825,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -870,10 +851,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -896,10 +877,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -922,10 +903,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -948,8 +929,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "StateDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "StateDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -969,10 +950,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -995,10 +976,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1021,10 +1002,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1047,10 +1028,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1073,10 +1054,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1099,10 +1080,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1125,10 +1106,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1151,10 +1132,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1177,10 +1158,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1203,10 +1184,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1229,10 +1210,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1255,10 +1236,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1281,10 +1262,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1307,10 +1288,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1333,10 +1314,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1359,10 +1340,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1385,10 +1366,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1411,10 +1392,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1435,10 +1416,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1461,10 +1442,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1487,10 +1468,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1513,10 +1494,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1539,10 +1520,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1565,10 +1546,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1591,10 +1572,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1617,10 +1598,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1643,10 +1624,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1669,10 +1650,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1695,10 +1676,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1721,10 +1702,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1747,8 +1728,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "StateDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "StateDefinition") public Element getOwner() { return owner; } @@ -1762,19 +1743,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "StateDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "StateDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1787,8 +1768,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "StateDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "StateDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1806,8 +1787,8 @@ 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 = "StateDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "StateDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1827,10 +1808,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1866,6 +1847,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "StateDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("state") private List state; @@ -1873,10 +1872,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_state", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getState() { if (state == null) { state = new ArrayList<>(); @@ -1899,10 +1898,10 @@ public void setState(List state) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1925,10 +1924,10 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1951,10 +1950,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1977,10 +1976,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2003,10 +2002,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl.java index bee893f8..0d7afe47 100644 --- a/app/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -74,8 +75,8 @@ public class StateSubactionMembershipImpl extends SysMLTypeImpl implements State @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "actionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "actionId", table = "StateSubactionMembership") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "action_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "action_id", table = "StateSubactionMembership") public ActionUsage getAction() { return action; } @@ -88,25 +89,25 @@ public void setAction(ActionUsage action) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "StateSubactionMembership_aliasId", - joinColumns = @JoinColumn(name = "StateSubactionMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "StateSubactionMembership_aliasIds", + joinColumns = @JoinColumn(name = "StateSubactionMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -118,10 +119,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,41 +139,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "StateSubactionMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "StateSubactionMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "StateSubactionMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "StateSubactionMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -182,8 +179,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "StateSubactionMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "StateSubactionMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -201,8 +198,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "StateSubactionMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "StateSubactionMembership") public Type getFeaturingType() { return featuringType; } @@ -215,40 +212,6 @@ public void setFeaturingType(Type featuringType) { - // @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 = "StateSubactionMembership") - 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 = "StateSubactionMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("kind") // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) private StateSubactionKind kind; @@ -272,8 +235,8 @@ public void setKind(StateSubactionKind kind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "StateSubactionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "StateSubactionMembership") public Element getMemberElement() { return memberElement; } @@ -286,21 +249,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "StateSubactionMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "StateSubactionMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -323,6 +287,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "StateSubactionMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -330,8 +312,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "StateSubactionMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "StateSubactionMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -344,14 +326,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "StateSubactionMembership") public String getName() { return name; @@ -371,10 +351,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -397,10 +377,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -421,8 +401,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "StateSubactionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "StateSubactionMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -435,13 +415,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "StateSubactionMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "StateSubactionMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "StateSubactionMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -454,15 +454,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "StateSubactionMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "StateSubactionMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -483,10 +523,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -509,8 +549,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "StateSubactionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "StateSubactionMembership") public Element getOwner() { return owner; } @@ -530,8 +570,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "StateSubactionMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "StateSubactionMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -545,19 +585,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "StateSubactionMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "StateSubactionMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -570,8 +610,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "StateSubactionMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "StateSubactionMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -589,8 +629,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "StateSubactionMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "StateSubactionMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -608,8 +648,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "StateSubactionMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "StateSubactionMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -629,8 +669,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "StateSubactionMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "StateSubactionMembership") public Type getOwningType() { return owningType; } @@ -670,10 +710,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -689,15 +729,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "StateSubactionMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -718,10 +776,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -744,10 +802,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateSubactionMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/StateUsageImpl.java b/app/org/omg/sysml/metamodel/impl/StateUsageImpl.java index f0af553b..6500fd90 100644 --- a/app/org/omg/sysml/metamodel/impl/StateUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/StateUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class StateUsageImpl extends SysMLTypeImpl implements StateUsage { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "StateUsage_aliasId", - joinColumns = @JoinColumn(name = "StateUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "StateUsage_aliasIds", + joinColumns = @JoinColumn(name = "StateUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,8 +274,8 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "doActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "doActionId", table = "StateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "doAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "doAction_id", table = "StateUsage") public ActionUsage getDoAction() { return doAction; } @@ -294,10 +295,10 @@ public void setDoAction(ActionUsage doAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -333,6 +334,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "StateUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -340,10 +357,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "StateUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "StateUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,8 +404,8 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "entryActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "entryActionId", table = "StateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "entryAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "entryAction_id", table = "StateUsage") public ActionUsage getEntryAction() { return entryAction; } @@ -408,8 +425,8 @@ public void setEntryAction(ActionUsage entryAction) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exitActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "exitActionId", table = "StateUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "exitAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "exitAction_id", table = "StateUsage") public ActionUsage getExitAction() { return exitAction; } @@ -429,10 +446,10 @@ public void setExitAction(ActionUsage exitAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -455,10 +472,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -481,10 +498,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -500,40 +517,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "StateUsage") - 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 = "StateUsage") - 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; @@ -541,10 +524,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -567,8 +550,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "StateUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "StateUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -588,10 +571,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -614,10 +597,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -640,10 +623,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -912,10 +895,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -938,10 +921,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -964,8 +947,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "StateUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "StateUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -978,14 +961,12 @@ public void setMultiplicity(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 = "StateUsage") public String getName() { return name; @@ -1005,10 +986,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1031,10 +1012,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1057,10 +1038,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1083,10 +1064,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1109,10 +1090,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1135,10 +1116,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1161,10 +1142,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1187,10 +1168,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1213,10 +1194,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1239,10 +1220,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1265,10 +1246,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1291,10 +1272,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1317,10 +1298,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1343,10 +1324,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1369,10 +1350,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1395,10 +1376,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1421,10 +1402,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1447,10 +1428,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1473,10 +1454,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1499,10 +1480,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1525,10 +1506,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1551,10 +1532,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1577,10 +1558,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1603,10 +1584,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1629,10 +1610,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1655,10 +1636,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1681,10 +1662,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1707,10 +1688,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1733,10 +1714,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1759,8 +1740,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "StateUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "StateUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1780,10 +1761,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1806,10 +1787,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1832,10 +1813,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1858,10 +1839,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1884,10 +1865,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1910,10 +1891,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1936,10 +1917,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1962,10 +1943,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1988,10 +1969,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2014,10 +1995,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2038,10 +2019,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2064,10 +2045,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2090,10 +2071,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2116,10 +2097,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2142,10 +2123,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2168,8 +2149,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "StateUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "StateUsage") public Element getOwner() { return owner; } @@ -2189,8 +2170,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "StateUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "StateUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2208,8 +2189,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "StateUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "StateUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2223,19 +2204,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "StateUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "StateUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2248,8 +2229,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "StateUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "StateUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2267,8 +2248,8 @@ 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 = "StateUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "StateUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2288,8 +2269,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "StateUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "StateUsage") public Type getOwningType() { return owningType; } @@ -2309,8 +2290,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "StateUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "StateUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2330,10 +2311,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2374,8 +2355,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "StateUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "StateUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2408,6 +2389,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "StateUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stateDefinition") private List stateDefinition; @@ -2415,10 +2414,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_stateDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStateDefinition() { if (stateDefinition == null) { stateDefinition = new ArrayList<>(); @@ -2441,10 +2440,10 @@ public void setStateDefinition(List stateDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2467,10 +2466,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2493,10 +2492,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2519,10 +2518,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2545,10 +2544,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "StateUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/StepImpl.java b/app/org/omg/sysml/metamodel/impl/StepImpl.java index 3f227dc2..45a05967 100644 --- a/app/org/omg/sysml/metamodel/impl/StepImpl.java +++ b/app/org/omg/sysml/metamodel/impl/StepImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Step") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class StepImpl extends SysMLTypeImpl implements Step { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Step_aliasId", - joinColumns = @JoinColumn(name = "StepId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Step_aliasIds", + joinColumns = @JoinColumn(name = "Step_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -195,10 +196,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -234,6 +235,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Step") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -241,10 +258,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -267,8 +284,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Step") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Step") public Type getEndOwningType() { return endOwningType; } @@ -288,10 +305,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -359,40 +376,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "Step") - 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 = "Step") - 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; @@ -400,10 +383,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -710,10 +693,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -736,8 +719,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Step") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Step") public Multiplicity getMultiplicity() { return multiplicity; } @@ -750,14 +733,12 @@ public void setMultiplicity(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 = "Step") public String getName() { return name; @@ -777,10 +758,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -803,10 +784,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -829,8 +810,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Step") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Step") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -850,10 +831,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1084,10 +1065,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1238,8 +1219,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Step") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Step") public Element getOwner() { return owner; } @@ -1257,8 +1238,8 @@ 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 = "Step") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Step") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1272,19 +1253,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Step") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Step") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1297,8 +1278,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Step") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Step") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1316,8 +1297,8 @@ 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 = "Step") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Step") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1337,8 +1318,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Step") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Step") public Type getOwningType() { return owningType; } @@ -1358,10 +1339,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1397,6 +1378,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Step") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1404,10 +1403,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1430,10 +1429,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Step_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/StructureImpl.java b/app/org/omg/sysml/metamodel/impl/StructureImpl.java index 2fd53bac..ca1dc41f 100644 --- a/app/org/omg/sysml/metamodel/impl/StructureImpl.java +++ b/app/org/omg/sysml/metamodel/impl/StructureImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Structure") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class StructureImpl extends SysMLTypeImpl implements Structure { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Structure_aliasId", - joinColumns = @JoinColumn(name = "StructureId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Structure_aliasIds", + joinColumns = @JoinColumn(name = "Structure_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Structure") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Structure") - 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 = "Structure") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Structure") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Structure") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "Structure") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Structure") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Structure") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -887,8 +868,8 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Structure") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Structure") public Element getOwner() { return owner; } @@ -902,19 +883,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Structure") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Structure") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -927,8 +908,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Structure") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Structure") public Namespace getOwningNamespace() { return owningNamespace; } @@ -946,8 +927,8 @@ 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 = "Structure") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Structure") public Relationship getOwningRelationship() { return owningRelationship; } @@ -980,6 +961,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Structure") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -987,10 +986,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Structure_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SubclassificationImpl.java b/app/org/omg/sysml/metamodel/impl/SubclassificationImpl.java index e6093059..4cf77a09 100644 --- a/app/org/omg/sysml/metamodel/impl/SubclassificationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SubclassificationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Subclassification") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SubclassificationImpl extends SysMLTypeImpl implements Subclassification { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Subclassification_aliasId", - joinColumns = @JoinColumn(name = "SubclassificationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Subclassification_aliasIds", + joinColumns = @JoinColumn(name = "Subclassification_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,67 +139,47 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("general") - private Type general; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "generalType"), fetch = FetchType.LAZY) - @JoinColumn(name = "generalId", table = "Subclassification") - public Type getGeneral() { - return general; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) - public void setGeneral(Type general) { - this.general = general; - } - - - - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Subclassification") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "Subclassification") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("general") + private Type general; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "Subclassification") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "general_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "general_id", table = "Subclassification") + public Type getGeneral() { + return general; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setGeneral(Type general) { + this.general = general; } - // @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 = "Subclassification") public String getName() { return name; @@ -218,10 +199,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -244,10 +225,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -268,10 +249,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -292,10 +273,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -318,8 +299,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Subclassification") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Subclassification") public Element getOwner() { return owner; } @@ -339,8 +320,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "owningClassifierType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningClassifierId", table = "Subclassification") + @Any(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "owningClassifier_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningClassifier_id", table = "Subclassification") public Classifier getOwningClassifier() { return owningClassifier; } @@ -354,19 +335,19 @@ public void setOwningClassifier(Classifier owningClassifier) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Subclassification") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Subclassification") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -379,8 +360,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Subclassification") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Subclassification") public Namespace getOwningNamespace() { return owningNamespace; } @@ -398,8 +379,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Subclassification") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Subclassification") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -417,8 +398,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Subclassification") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Subclassification") public Relationship getOwningRelationship() { return owningRelationship; } @@ -438,8 +419,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Subclassification") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Subclassification") public Type getOwningType() { return owningType; } @@ -479,10 +460,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -498,15 +479,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Subclassification") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -527,8 +526,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specificType"), fetch = FetchType.LAZY) - @JoinColumn(name = "specificId", table = "Subclassification") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specific_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "specific_id", table = "Subclassification") public Type getSpecific() { return specific; } @@ -546,8 +545,8 @@ public void setSpecific(Type specific) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "subclassifierType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subclassifierId", table = "Subclassification") + @Any(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "subclassifier_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subclassifier_id", table = "Subclassification") public Classifier getSubclassifier() { return subclassifier; } @@ -565,8 +564,8 @@ public void setSubclassifier(Classifier subclassifier) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "superclassifierType"), fetch = FetchType.LAZY) - @JoinColumn(name = "superclassifierId", table = "Subclassification") + @Any(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "superclassifier_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "superclassifier_id", table = "Subclassification") public Classifier getSuperclassifier() { return superclassifier; } @@ -584,10 +583,10 @@ public void setSuperclassifier(Classifier superclassifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -610,10 +609,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subclassification_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SubjectMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/SubjectMembershipImpl.java index 4ab8cf44..59436b6d 100644 --- a/app/org/omg/sysml/metamodel/impl/SubjectMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SubjectMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "SubjectMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SubjectMembershipImpl extends SysMLTypeImpl implements SubjectMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SubjectMembership_aliasId", - joinColumns = @JoinColumn(name = "SubjectMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SubjectMembership_aliasIds", + joinColumns = @JoinColumn(name = "SubjectMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "SubjectMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "SubjectMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "SubjectMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "SubjectMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "SubjectMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "SubjectMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "SubjectMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "SubjectMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "SubjectMembership") - 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 = "SubjectMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "SubjectMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "SubjectMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "SubjectMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "SubjectMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,21 +250,20 @@ public void setMemberName(String memberName) { - // @info.archinnov.achilles.annotations.Column("memberParameter") - private Feature memberParameter; + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberParameterId", table = "SubjectMembership") - public Feature getMemberParameter() { - return memberParameter; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "SubjectMembership") + public String getMemberShortName() { + return memberShortName; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberParameter(Feature memberParameter) { - this.memberParameter = memberParameter; + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; } @@ -312,8 +275,8 @@ public void setMemberParameter(Feature memberParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "SubjectMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "SubjectMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -326,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "SubjectMembership") public String getName() { return name; @@ -353,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -379,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -403,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "SubjectMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "SubjectMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -417,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "SubjectMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "SubjectMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "SubjectMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -436,13 +417,33 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "SubjectMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberParameter") private Feature ownedMemberParameter; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberParameterId", table = "SubjectMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberParameter_id", table = "SubjectMembership") public Feature getOwnedMemberParameter() { return ownedMemberParameter; } @@ -455,15 +456,35 @@ public void setOwnedMemberParameter(Feature ownedMemberParameter) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "SubjectMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -484,10 +505,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -508,8 +529,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedSubjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedSubjectParameterId", table = "SubjectMembership") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedSubjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedSubjectParameter_id", table = "SubjectMembership") public Usage getOwnedSubjectParameter() { return ownedSubjectParameter; } @@ -529,8 +550,8 @@ public void setOwnedSubjectParameter(Usage ownedSubjectParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SubjectMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SubjectMembership") public Element getOwner() { return owner; } @@ -550,8 +571,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "SubjectMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "SubjectMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -565,19 +586,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SubjectMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SubjectMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -590,8 +611,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SubjectMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SubjectMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -609,8 +630,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "SubjectMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "SubjectMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -628,8 +649,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "SubjectMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SubjectMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -649,8 +670,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SubjectMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SubjectMembership") public Type getOwningType() { return owningType; } @@ -690,10 +711,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -709,15 +730,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SubjectMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -738,10 +777,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -764,10 +803,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SubjectMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SubsettingImpl.java b/app/org/omg/sysml/metamodel/impl/SubsettingImpl.java index d7ca2787..7f51061e 100644 --- a/app/org/omg/sysml/metamodel/impl/SubsettingImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SubsettingImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Subsetting") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SubsettingImpl extends SysMLTypeImpl implements Subsetting { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Subsetting_aliasId", - joinColumns = @JoinColumn(name = "SubsettingId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Subsetting_aliasIds", + joinColumns = @JoinColumn(name = "Subsetting_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,67 +139,47 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("general") - private Type general; - - @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "generalType"), fetch = FetchType.LAZY) - @JoinColumn(name = "generalId", table = "Subsetting") - public Type getGeneral() { - return general; - } - - @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) - public void setGeneral(Type general) { - this.general = general; - } - - - - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "Subsetting") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "Subsetting") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("general") + private Type general; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "Subsetting") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "general_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "general_id", table = "Subsetting") + public Type getGeneral() { + return general; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = TypeImpl.class) + public void setGeneral(Type general) { + this.general = general; } - // @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 = "Subsetting") public String getName() { return name; @@ -218,10 +199,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -244,10 +225,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -268,10 +249,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -292,10 +273,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -318,8 +299,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Subsetting") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Subsetting") public Element getOwner() { return owner; } @@ -339,8 +320,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureId", table = "Subsetting") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeature_id", table = "Subsetting") public Feature getOwningFeature() { return owningFeature; } @@ -354,19 +335,19 @@ public void setOwningFeature(Feature owningFeature) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Subsetting") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Subsetting") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -379,8 +360,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Subsetting") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Subsetting") public Namespace getOwningNamespace() { return owningNamespace; } @@ -398,8 +379,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Subsetting") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Subsetting") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -417,8 +398,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Subsetting") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Subsetting") public Relationship getOwningRelationship() { return owningRelationship; } @@ -438,8 +419,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Subsetting") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Subsetting") public Type getOwningType() { return owningType; } @@ -479,10 +460,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -498,15 +479,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Subsetting") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -527,8 +526,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specificType"), fetch = FetchType.LAZY) - @JoinColumn(name = "specificId", table = "Subsetting") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "specific_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "specific_id", table = "Subsetting") public Type getSpecific() { return specific; } @@ -546,8 +545,8 @@ public void setSpecific(Type specific) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettedFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subsettedFeatureId", table = "Subsetting") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettedFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subsettedFeature_id", table = "Subsetting") public Feature getSubsettedFeature() { return subsettedFeature; } @@ -565,8 +564,8 @@ public void setSubsettedFeature(Feature subsettedFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettingFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subsettingFeatureId", table = "Subsetting") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "subsettingFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subsettingFeature_id", table = "Subsetting") public Feature getSubsettingFeature() { return subsettingFeature; } @@ -584,10 +583,10 @@ public void setSubsettingFeature(Feature subsettingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -610,10 +609,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Subsetting_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl.java b/app/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl.java index 482ab495..065ffc33 100644 --- a/app/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "SuccessionAsUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SuccessionAsUsageImpl extends SysMLTypeImpl implements SuccessionAsUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SuccessionAsUsage_aliasId", - joinColumns = @JoinColumn(name = "SuccessionAsUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SuccessionAsUsage_aliasIds", + joinColumns = @JoinColumn(name = "SuccessionAsUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -299,10 +300,10 @@ public void setDocumentation(List documentation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_effectStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getEffectStep() { if (effectStep == null) { effectStep = new ArrayList<>(); @@ -338,6 +339,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SuccessionAsUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -345,10 +362,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -371,8 +388,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SuccessionAsUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SuccessionAsUsage") public Type getEndOwningType() { return endOwningType; } @@ -392,10 +409,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -470,10 +487,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_guardExpression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getGuardExpression() { if (guardExpression == null) { guardExpression = new ArrayList<>(); @@ -489,40 +506,6 @@ public void setGuardExpression(Collection guardExpression) { - // @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 = "SuccessionAsUsage") - 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 = "SuccessionAsUsage") - 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; @@ -530,10 +513,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -556,10 +539,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -582,10 +565,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -608,10 +591,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -864,10 +847,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -890,10 +873,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -916,8 +899,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SuccessionAsUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SuccessionAsUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -930,14 +913,12 @@ public void setMultiplicity(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 = "SuccessionAsUsage") public String getName() { return name; @@ -957,10 +938,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -983,10 +964,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1009,10 +990,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1035,10 +1016,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1061,10 +1042,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1087,10 +1068,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1113,10 +1094,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1139,10 +1120,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1165,10 +1146,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1321,10 +1302,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1347,10 +1328,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1373,10 +1354,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1399,10 +1380,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1425,10 +1406,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1451,10 +1432,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1477,10 +1458,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1503,10 +1484,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1529,10 +1510,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1555,10 +1536,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1581,10 +1562,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1607,10 +1588,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1633,10 +1614,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1659,10 +1640,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1685,8 +1666,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SuccessionAsUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SuccessionAsUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1706,10 +1687,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1732,10 +1713,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1758,10 +1739,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1784,10 +1765,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1810,10 +1791,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1836,10 +1817,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1862,10 +1843,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1888,10 +1869,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1914,10 +1895,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1940,10 +1921,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1964,10 +1945,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1988,10 +1969,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2014,10 +1995,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2040,10 +2021,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2066,10 +2047,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2092,10 +2073,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2118,8 +2099,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SuccessionAsUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SuccessionAsUsage") public Element getOwner() { return owner; } @@ -2139,8 +2120,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "SuccessionAsUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "SuccessionAsUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2158,8 +2139,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "SuccessionAsUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SuccessionAsUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2173,19 +2154,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SuccessionAsUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SuccessionAsUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2198,8 +2179,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SuccessionAsUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SuccessionAsUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2217,8 +2198,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "SuccessionAsUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "SuccessionAsUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2236,8 +2217,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "SuccessionAsUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SuccessionAsUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2257,8 +2238,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SuccessionAsUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SuccessionAsUsage") public Type getOwningType() { return owningType; } @@ -2278,8 +2259,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "SuccessionAsUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "SuccessionAsUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2319,10 +2300,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2345,10 +2326,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2364,15 +2345,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SuccessionAsUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2395,8 +2394,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "SuccessionAsUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "SuccessionAsUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2414,10 +2413,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2466,10 +2465,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2492,8 +2491,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStepType"), fetch = FetchType.LAZY) - @JoinColumn(name = "transitionStepId", table = "SuccessionAsUsage") + @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStep_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "transitionStep_id", table = "SuccessionAsUsage") public Step getTransitionStep() { return transitionStep; } @@ -2513,10 +2512,10 @@ public void setTransitionStep(Step transitionStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_triggerStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTriggerStep() { if (triggerStep == null) { triggerStep = new ArrayList<>(); @@ -2539,10 +2538,10 @@ public void setTriggerStep(Collection triggerStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2565,10 +2564,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2591,10 +2590,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2617,10 +2616,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionAsUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl.java index 44574c6d..9785ddb7 100644 --- a/app/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "SuccessionFlowConnectionUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SuccessionFlowConnectionUsageImpl extends SysMLTypeImpl implements SuccessionFlowConnectionUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SuccessionFlowConnectionUsage_aliasId", - joinColumns = @JoinColumn(name = "SuccessionFlowConnectionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SuccessionFlowConnectionUsage_aliasIds", + joinColumns = @JoinColumn(name = "SuccessionFlowConnectionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationStructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_connectionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getConnectionDefinition() { if (connectionDefinition == null) { connectionDefinition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectionDefinition(List connectionDefinit @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -255,10 +256,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -281,10 +282,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -325,10 +326,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -351,10 +352,10 @@ public void setDocumentation(List documentation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_effectStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getEffectStep() { if (effectStep == null) { effectStep = new ArrayList<>(); @@ -390,6 +391,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SuccessionFlowConnectionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -397,10 +414,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -423,8 +440,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SuccessionFlowConnectionUsage") public Type getEndOwningType() { return endOwningType; } @@ -444,10 +461,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -470,10 +487,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -496,10 +513,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -522,10 +539,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_guardExpression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getGuardExpression() { if (guardExpression == null) { guardExpression = new ArrayList<>(); @@ -541,40 +558,6 @@ public void setGuardExpression(Collection guardExpression) { - // @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 = "SuccessionFlowConnectionUsage") - 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 = "SuccessionFlowConnectionUsage") - 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; @@ -582,10 +565,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -608,8 +591,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "SuccessionFlowConnectionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -629,10 +612,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -655,10 +638,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -681,10 +664,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -953,10 +936,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -979,10 +962,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_itemFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFeature() { if (itemFeature == null) { itemFeature = new ArrayList<>(); @@ -1005,10 +988,10 @@ public void setItemFeature(Collection itemFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_itemFlowEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowEnd() { if (itemFlowEnd == null) { itemFlowEnd = new ArrayList<>(); @@ -1031,10 +1014,10 @@ public void setItemFlowEnd(Collection itemFlowEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_itemFlowFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowFeature() { if (itemFlowFeature == null) { itemFlowFeature = new ArrayList<>(); @@ -1057,10 +1040,10 @@ public void setItemFlowFeature(Collection itemFlowFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_itemType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemType() { if (itemType == null) { itemType = new ArrayList<>(); @@ -1083,10 +1066,10 @@ public void setItemType(List itemType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -1109,10 +1092,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1135,8 +1118,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SuccessionFlowConnectionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1149,14 +1132,12 @@ public void setMultiplicity(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 = "SuccessionFlowConnectionUsage") public String getName() { return name; @@ -1176,10 +1157,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1358,10 +1339,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1384,10 +1365,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1410,10 +1391,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1436,10 +1417,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1462,10 +1443,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1488,10 +1469,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1514,10 +1495,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1540,10 +1521,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1566,10 +1547,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1592,10 +1573,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1618,10 +1599,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1644,10 +1625,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1670,10 +1651,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1696,10 +1677,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1722,10 +1703,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1774,10 +1755,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1800,10 +1781,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1826,10 +1807,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1852,10 +1833,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1878,10 +1859,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1904,10 +1885,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1930,8 +1911,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SuccessionFlowConnectionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1951,10 +1932,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1977,10 +1958,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -2003,10 +1984,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -2029,10 +2010,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -2055,10 +2036,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -2081,10 +2062,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -2107,10 +2088,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2133,10 +2114,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2159,10 +2140,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2185,10 +2166,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2209,10 +2190,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -2233,10 +2214,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2259,10 +2240,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2285,10 +2266,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2311,10 +2292,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2337,10 +2318,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2363,8 +2344,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SuccessionFlowConnectionUsage") public Element getOwner() { return owner; } @@ -2384,8 +2365,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "SuccessionFlowConnectionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2403,8 +2384,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SuccessionFlowConnectionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2418,19 +2399,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SuccessionFlowConnectionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SuccessionFlowConnectionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2443,8 +2424,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SuccessionFlowConnectionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2462,8 +2443,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "SuccessionFlowConnectionUsage") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -2481,8 +2462,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SuccessionFlowConnectionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2502,8 +2483,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SuccessionFlowConnectionUsage") public Type getOwningType() { return owningType; } @@ -2523,8 +2504,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "SuccessionFlowConnectionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2544,10 +2525,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2570,10 +2551,10 @@ public void setParameter(List parameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2614,8 +2595,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "SuccessionFlowConnectionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2655,10 +2636,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -2681,10 +2662,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -2700,15 +2681,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SuccessionFlowConnectionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -2731,8 +2730,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "SuccessionFlowConnectionUsage") public Feature getSourceFeature() { return sourceFeature; } @@ -2752,10 +2751,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_sourceOutputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSourceOutputFeature() { if (sourceOutputFeature == null) { sourceOutputFeature = new ArrayList<>(); @@ -2776,10 +2775,10 @@ public void setSourceOutputFeature(List sourceOutputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -2802,10 +2801,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -2828,10 +2827,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_targetInputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTargetInputFeature() { if (targetInputFeature == null) { targetInputFeature = new ArrayList<>(); @@ -2854,10 +2853,10 @@ public void setTargetInputFeature(List targetInputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2880,8 +2879,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStepType"), fetch = FetchType.LAZY) - @JoinColumn(name = "transitionStepId", table = "SuccessionFlowConnectionUsage") + @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStep_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "transitionStep_id", table = "SuccessionFlowConnectionUsage") public Step getTransitionStep() { return transitionStep; } @@ -2901,10 +2900,10 @@ public void setTransitionStep(Step transitionStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_triggerStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTriggerStep() { if (triggerStep == null) { triggerStep = new ArrayList<>(); @@ -2927,10 +2926,10 @@ public void setTriggerStep(Collection triggerStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2953,10 +2952,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2979,10 +2978,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -3005,10 +3004,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionFlowConnectionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SuccessionImpl.java b/app/org/omg/sysml/metamodel/impl/SuccessionImpl.java index 5e5dfddf..3136aaa2 100644 --- a/app/org/omg/sysml/metamodel/impl/SuccessionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SuccessionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Succession") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SuccessionImpl extends SysMLTypeImpl implements Succession { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Succession_aliasId", - joinColumns = @JoinColumn(name = "SuccessionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Succession_aliasIds", + joinColumns = @JoinColumn(name = "Succession_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -247,10 +248,10 @@ public void setDocumentation(List documentation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_effectStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getEffectStep() { if (effectStep == null) { effectStep = new ArrayList<>(); @@ -286,6 +287,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Succession") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -293,10 +310,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -319,8 +336,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Succession") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Succession") public Type getEndOwningType() { return endOwningType; } @@ -340,10 +357,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_guardExpression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getGuardExpression() { if (guardExpression == null) { guardExpression = new ArrayList<>(); @@ -437,40 +454,6 @@ public void setGuardExpression(Collection guardExpression) { - // @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 = "Succession") - 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 = "Succession") - 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; @@ -478,10 +461,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -530,10 +513,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -556,10 +539,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -778,10 +761,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -804,10 +787,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -830,8 +813,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Succession") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Succession") public Multiplicity getMultiplicity() { return multiplicity; } @@ -844,14 +827,12 @@ public void setMultiplicity(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 = "Succession") public String getName() { return name; @@ -871,10 +852,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -897,10 +878,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -923,8 +904,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Succession") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Succession") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -944,10 +925,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -970,10 +951,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -996,10 +977,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1022,10 +1003,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1048,10 +1029,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1074,10 +1055,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1100,10 +1081,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1126,10 +1107,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1152,10 +1133,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1178,10 +1159,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1226,10 +1207,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1252,10 +1233,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1278,10 +1259,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1304,10 +1285,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1356,8 +1337,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Succession") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Succession") public Element getOwner() { return owner; } @@ -1375,8 +1356,8 @@ 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 = "Succession") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Succession") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1390,19 +1371,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Succession") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Succession") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1415,8 +1396,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Succession") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Succession") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1434,8 +1415,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "Succession") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "Succession") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1453,8 +1434,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "Succession") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Succession") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1474,8 +1455,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Succession") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Succession") public Type getOwningType() { return owningType; } @@ -1515,10 +1496,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1541,10 +1522,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -1560,15 +1541,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Succession") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1591,8 +1590,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "Succession") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "Succession") public Feature getSourceFeature() { return sourceFeature; } @@ -1610,10 +1609,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1636,10 +1635,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -1662,10 +1661,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1688,8 +1687,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStepType"), fetch = FetchType.LAZY) - @JoinColumn(name = "transitionStepId", table = "Succession") + @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStep_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "transitionStep_id", table = "Succession") public Step getTransitionStep() { return transitionStep; } @@ -1709,10 +1708,10 @@ public void setTransitionStep(Step transitionStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_triggerStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTriggerStep() { if (triggerStep == null) { triggerStep = new ArrayList<>(); @@ -1735,10 +1734,10 @@ public void setTriggerStep(Collection triggerStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Succession_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl.java b/app/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl.java index 59e703a9..775d6aff 100644 --- a/app/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "SuccessionItemFlow") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class SuccessionItemFlowImpl extends SysMLTypeImpl implements SuccessionItemFlow { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "SuccessionItemFlow_aliasId", - joinColumns = @JoinColumn(name = "SuccessionItemFlowId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "SuccessionItemFlow_aliasIds", + joinColumns = @JoinColumn(name = "SuccessionItemFlow_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AssociationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_association", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getAssociation() { if (association == null) { association = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setAssociation(Collection association) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_connectorEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getConnectorEnd() { if (connectorEnd == null) { connectorEnd = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setConnectorEnd(Collection connectorEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -247,10 +248,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDocumentation(List documentation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_effectStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getEffectStep() { if (effectStep == null) { effectStep = new ArrayList<>(); @@ -312,6 +313,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "SuccessionItemFlow") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -319,10 +336,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -345,8 +362,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "SuccessionItemFlow") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "SuccessionItemFlow") public Type getEndOwningType() { return endOwningType; } @@ -366,10 +383,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_guardExpression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getGuardExpression() { if (guardExpression == null) { guardExpression = new ArrayList<>(); @@ -463,40 +480,6 @@ public void setGuardExpression(Collection guardExpression) { - // @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 = "SuccessionItemFlow") - 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 = "SuccessionItemFlow") - 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; @@ -504,10 +487,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -530,10 +513,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -556,10 +539,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -582,10 +565,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -804,10 +787,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_itemFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFeature() { if (itemFeature == null) { itemFeature = new ArrayList<>(); @@ -830,10 +813,10 @@ public void setItemFeature(Collection itemFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowEndMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_itemFlowEnd", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowEnd() { if (itemFlowEnd == null) { itemFlowEnd = new ArrayList<>(); @@ -856,10 +839,10 @@ public void setItemFlowEnd(Collection itemFlowEnd) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemFlowFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_itemFlowFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getItemFlowFeature() { if (itemFlowFeature == null) { itemFlowFeature = new ArrayList<>(); @@ -882,10 +865,10 @@ public void setItemFlowFeature(Collection itemFlowFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_itemType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemType() { if (itemType == null) { itemType = new ArrayList<>(); @@ -908,10 +891,10 @@ public void setItemType(List itemType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -934,10 +917,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -960,8 +943,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "SuccessionItemFlow") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "SuccessionItemFlow") public Multiplicity getMultiplicity() { return multiplicity; } @@ -974,14 +957,12 @@ public void setMultiplicity(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 = "SuccessionItemFlow") public String getName() { return name; @@ -1001,10 +982,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1027,10 +1008,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1053,8 +1034,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "SuccessionItemFlow") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "SuccessionItemFlow") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1074,10 +1055,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1100,10 +1081,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1126,10 +1107,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1152,10 +1133,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1178,10 +1159,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1204,10 +1185,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1230,10 +1211,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1256,10 +1237,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1282,10 +1263,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1308,10 +1289,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1332,10 +1313,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1486,8 +1467,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "SuccessionItemFlow") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "SuccessionItemFlow") public Element getOwner() { return owner; } @@ -1505,8 +1486,8 @@ 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 = "SuccessionItemFlow") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "SuccessionItemFlow") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1520,19 +1501,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "SuccessionItemFlow") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "SuccessionItemFlow") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1545,8 +1526,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "SuccessionItemFlow") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "SuccessionItemFlow") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1564,8 +1545,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "SuccessionItemFlow") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "SuccessionItemFlow") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -1583,8 +1564,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "SuccessionItemFlow") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "SuccessionItemFlow") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1604,8 +1585,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "SuccessionItemFlow") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "SuccessionItemFlow") public Type getOwningType() { return owningType; } @@ -1625,10 +1606,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1671,10 +1652,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -1697,10 +1678,10 @@ public void setRelatedElement(List relatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_relatedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedFeature() { if (relatedFeature == null) { relatedFeature = new ArrayList<>(); @@ -1716,15 +1697,33 @@ public void setRelatedFeature(List relatedFeature) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "SuccessionItemFlow") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -1747,8 +1746,8 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceFeatureId", table = "SuccessionItemFlow") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "sourceFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "sourceFeature_id", table = "SuccessionItemFlow") public Feature getSourceFeature() { return sourceFeature; } @@ -1768,10 +1767,10 @@ public void setSourceFeature(Feature sourceFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_sourceOutputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSourceOutputFeature() { if (sourceOutputFeature == null) { sourceOutputFeature = new ArrayList<>(); @@ -1792,10 +1791,10 @@ public void setSourceOutputFeature(List sourceOutputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -1818,10 +1817,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_targetFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTargetFeature() { if (targetFeature == null) { targetFeature = new ArrayList<>(); @@ -1844,10 +1843,10 @@ public void setTargetFeature(Collection targetFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_targetInputFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTargetInputFeature() { if (targetInputFeature == null) { targetInputFeature = new ArrayList<>(); @@ -1870,10 +1869,10 @@ public void setTargetInputFeature(List targetInputFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1896,8 +1895,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStepType"), fetch = FetchType.LAZY) - @JoinColumn(name = "transitionStepId", table = "SuccessionItemFlow") + @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionStep_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "transitionStep_id", table = "SuccessionItemFlow") public Step getTransitionStep() { return transitionStep; } @@ -1917,10 +1916,10 @@ public void setTransitionStep(Step transitionStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_triggerStep", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTriggerStep() { if (triggerStep == null) { triggerStep = new ArrayList<>(); @@ -1943,10 +1942,10 @@ public void setTriggerStep(Collection triggerStep) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "SuccessionItemFlow_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java b/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java index 695a5ddb..522a612c 100644 --- a/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/SysMLTypeImpl.java @@ -33,18 +33,18 @@ public abstract class SysMLTypeImpl extends DataImpl implements Data { - public abstract java.util.UUID getIdentifier(); + public abstract java.util.UUID getElementId(); - public abstract void setIdentifier(java.util.UUID identifier); + public abstract void setElementId(java.util.UUID identifier); @Transient @JsonGetter(value = IDENTITY_FIELD) public java.util.UUID getId() { - return getIdentifier(); + return getElementId(); } @JsonSetter(value = IDENTITY_FIELD) public void setId(java.util.UUID id) { - setIdentifier(id); + setElementId(id); } } diff --git a/app/org/omg/sysml/metamodel/impl/TargetEndImpl.java b/app/org/omg/sysml/metamodel/impl/TargetEndImpl.java index b3542501..10cc4a6d 100644 --- a/app/org/omg/sysml/metamodel/impl/TargetEndImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TargetEndImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "TargetEnd") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class TargetEndImpl extends SysMLTypeImpl implements TargetEnd { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "TargetEnd_aliasId", - joinColumns = @JoinColumn(name = "TargetEndId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "TargetEnd_aliasIds", + joinColumns = @JoinColumn(name = "TargetEnd_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -169,10 +170,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -208,6 +209,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "TargetEnd") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -215,10 +232,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -241,8 +258,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "TargetEnd") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "TargetEnd") public Type getEndOwningType() { return endOwningType; } @@ -262,10 +279,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -288,10 +305,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -314,10 +331,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -333,40 +350,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "TargetEnd") - 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 = "TargetEnd") - 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; @@ -374,10 +357,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -400,10 +383,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -426,10 +409,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -658,10 +641,10 @@ public void setIsUnique(Boolean isUnique) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -684,10 +667,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -710,8 +693,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "TargetEnd") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "TargetEnd") public Multiplicity getMultiplicity() { return multiplicity; } @@ -724,14 +707,12 @@ public void setMultiplicity(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 = "TargetEnd") public String getName() { return name; @@ -751,10 +732,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -777,10 +758,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -803,8 +784,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "TargetEnd") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "TargetEnd") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -824,10 +805,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -850,10 +831,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -876,10 +857,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -902,10 +883,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -928,10 +909,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -954,10 +935,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -980,10 +961,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1006,10 +987,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1032,10 +1013,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1058,10 +1039,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1212,8 +1193,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "TargetEnd") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "TargetEnd") public Element getOwner() { return owner; } @@ -1231,8 +1212,8 @@ 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 = "TargetEnd") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "TargetEnd") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1246,19 +1227,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "TargetEnd") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "TargetEnd") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1271,8 +1252,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "TargetEnd") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "TargetEnd") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1290,8 +1271,8 @@ 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 = "TargetEnd") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "TargetEnd") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1311,8 +1292,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "TargetEnd") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "TargetEnd") public Type getOwningType() { return owningType; } @@ -1345,6 +1326,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "TargetEnd") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1352,10 +1351,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1378,10 +1377,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TargetEnd_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/TextualRepresentationImpl.java b/app/org/omg/sysml/metamodel/impl/TextualRepresentationImpl.java index d2cbe2f3..83464c5f 100644 --- a/app/org/omg/sysml/metamodel/impl/TextualRepresentationImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TextualRepresentationImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "TextualRepresentation") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class TextualRepresentationImpl extends SysMLTypeImpl implements TextualRepresentation { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "TextualRepresentation_aliasId", - joinColumns = @JoinColumn(name = "TextualRepresentationId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "TextualRepresentation_aliasIds", + joinColumns = @JoinColumn(name = "TextualRepresentation_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_annotatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotatedElement() { if (annotatedElement == null) { annotatedElement = new ArrayList<>(); @@ -123,10 +124,10 @@ public void setAnnotatedElement(List annotatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_annotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAnnotation() { if (annotation == null) { annotation = new ArrayList<>(); @@ -167,10 +168,10 @@ public void setBody(String body) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -206,36 +207,18 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "TextualRepresentation") - 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 = "TextualRepresentation") - public java.util.UUID getIdentifier() { - return identifier; + @javax.persistence.Column(name = "elementId", table = "TextualRepresentation") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -258,14 +241,12 @@ public void setLanguage(String language) { - // @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 = "TextualRepresentation") public String getName() { return name; @@ -285,10 +266,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -311,10 +292,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -335,10 +316,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -361,8 +342,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "TextualRepresentation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "TextualRepresentation") public Element getOwner() { return owner; } @@ -376,19 +357,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "TextualRepresentation") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "TextualRepresentation") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -401,8 +382,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "TextualRepresentation") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "TextualRepresentation") public Namespace getOwningNamespace() { return owningNamespace; } @@ -420,8 +401,8 @@ 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 = "TextualRepresentation") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "TextualRepresentation") public Relationship getOwningRelationship() { return owningRelationship; } @@ -461,8 +442,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "representedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "representedElementId", table = "TextualRepresentation") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "representedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "representedElement_id", table = "TextualRepresentation") public Element getRepresentedElement() { return representedElement; } @@ -475,6 +456,24 @@ public void setRepresentedElement(Element representedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "TextualRepresentation") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -482,10 +481,10 @@ public void setRepresentedElement(Element representedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TextualRepresentation_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl.java index 35092102..2dff6d34 100644 --- a/app/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "TransitionFeatureMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class TransitionFeatureMembershipImpl extends SysMLTypeImpl implements TransitionFeatureMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "TransitionFeatureMembership_aliasId", - joinColumns = @JoinColumn(name = "TransitionFeatureMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "TransitionFeatureMembership_aliasIds", + joinColumns = @JoinColumn(name = "TransitionFeatureMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "TransitionFeatureMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "TransitionFeatureMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "TransitionFeatureMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "TransitionFeatureMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "TransitionFeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "TransitionFeatureMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "TransitionFeatureMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "TransitionFeatureMembership") public Type getFeaturingType() { return featuringType; } @@ -196,40 +193,6 @@ public void setFeaturingType(Type featuringType) { - // @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 = "TransitionFeatureMembership") - 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 = "TransitionFeatureMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("kind") // @info.archinnov.achilles.annotations.Enumerated(info.archinnov.achilles.annotations.Enumerated.Encoding.NAME) private TransitionFeatureKind kind; @@ -253,8 +216,8 @@ public void setKind(TransitionFeatureKind kind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "TransitionFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "TransitionFeatureMembership") public Element getMemberElement() { return memberElement; } @@ -267,21 +230,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "TransitionFeatureMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "TransitionFeatureMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -304,6 +268,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "TransitionFeatureMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -311,8 +293,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "TransitionFeatureMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "TransitionFeatureMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -325,14 +307,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "TransitionFeatureMembership") public String getName() { return name; @@ -352,10 +332,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -378,10 +358,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -402,8 +382,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "TransitionFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "TransitionFeatureMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -416,13 +396,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "TransitionFeatureMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "TransitionFeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "TransitionFeatureMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -435,15 +435,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "TransitionFeatureMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "TransitionFeatureMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -464,10 +504,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -490,8 +530,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "TransitionFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "TransitionFeatureMembership") public Element getOwner() { return owner; } @@ -511,8 +551,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "TransitionFeatureMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "TransitionFeatureMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -526,19 +566,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "TransitionFeatureMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "TransitionFeatureMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -551,8 +591,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "TransitionFeatureMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "TransitionFeatureMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -570,8 +610,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "TransitionFeatureMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "TransitionFeatureMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -589,8 +629,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "TransitionFeatureMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "TransitionFeatureMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -610,8 +650,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "TransitionFeatureMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "TransitionFeatureMembership") public Type getOwningType() { return owningType; } @@ -651,10 +691,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -670,15 +710,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "TransitionFeatureMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -699,10 +757,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -725,10 +783,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionFeatureMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -749,8 +807,8 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "transitionFeatureId", table = "TransitionFeatureMembership") + @Any(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "transitionFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "transitionFeature_id", table = "TransitionFeatureMembership") public Step getTransitionFeature() { return transitionFeature; } diff --git a/app/org/omg/sysml/metamodel/impl/TransitionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/TransitionUsageImpl.java index f5d01de0..6b2a4395 100644 --- a/app/org/omg/sysml/metamodel/impl/TransitionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TransitionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class TransitionUsageImpl extends SysMLTypeImpl implements TransitionUsag @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "TransitionUsage_aliasId", - joinColumns = @JoinColumn(name = "TransitionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "TransitionUsage_aliasIds", + joinColumns = @JoinColumn(name = "TransitionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -273,10 +274,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -299,10 +300,10 @@ public void setDocumentation(List documentation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_effectAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getEffectAction() { if (effectAction == null) { effectAction = new ArrayList<>(); @@ -338,6 +339,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "TransitionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -345,10 +362,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -371,8 +388,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "TransitionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "TransitionUsage") public Type getEndOwningType() { return endOwningType; } @@ -392,10 +409,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -418,10 +435,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -444,10 +461,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -470,10 +487,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_guardExpression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getGuardExpression() { if (guardExpression == null) { guardExpression = new ArrayList<>(); @@ -489,40 +506,6 @@ public void setGuardExpression(Collection guardExpression) { - // @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 = "TransitionUsage") - 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 = "TransitionUsage") - 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; @@ -530,10 +513,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -556,8 +539,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "TransitionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "TransitionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -577,10 +560,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -603,10 +586,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -629,10 +612,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -885,10 +868,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -911,10 +894,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -937,8 +920,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "TransitionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "TransitionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -951,14 +934,12 @@ public void setMultiplicity(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 = "TransitionUsage") public String getName() { return name; @@ -978,10 +959,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1680,10 +1661,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1706,10 +1687,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1732,8 +1713,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "TransitionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "TransitionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1753,10 +1734,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1961,10 +1942,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1987,10 +1968,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2089,10 +2070,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2115,10 +2096,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2141,8 +2122,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "TransitionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "TransitionUsage") public Element getOwner() { return owner; } @@ -2162,8 +2143,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "TransitionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "TransitionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2181,8 +2162,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "TransitionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "TransitionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2196,19 +2177,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "TransitionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "TransitionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2221,8 +2202,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "TransitionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "TransitionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2240,8 +2221,8 @@ 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 = "TransitionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "TransitionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2261,8 +2242,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "TransitionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "TransitionUsage") public Type getOwningType() { return owningType; } @@ -2282,8 +2263,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "TransitionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "TransitionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2303,10 +2284,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2347,8 +2328,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "TransitionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "TransitionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2381,6 +2362,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "TransitionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("source") private ActionUsage source; @@ -2388,8 +2387,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "sourceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "sourceId", table = "TransitionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "source_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "source_id", table = "TransitionUsage") public ActionUsage getSource() { return source; } @@ -2409,8 +2408,8 @@ public void setSource(ActionUsage source) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "SuccessionMetaDef", metaColumn = @javax.persistence.Column(name = "successionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "successionId", table = "TransitionUsage") + @Any(metaDef = "SuccessionMetaDef", metaColumn = @javax.persistence.Column(name = "succession_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "succession_id", table = "TransitionUsage") public Succession getSuccession() { return succession; } @@ -2430,8 +2429,8 @@ public void setSuccession(Succession succession) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "targetType"), fetch = FetchType.LAZY) - @JoinColumn(name = "targetId", table = "TransitionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "target_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "target_id", table = "TransitionUsage") public ActionUsage getTarget() { return target; } @@ -2451,10 +2450,10 @@ public void setTarget(ActionUsage target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2477,10 +2476,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AcceptActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AcceptActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_triggerAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getTriggerAction() { if (triggerAction == null) { triggerAction = new ArrayList<>(); @@ -2503,10 +2502,10 @@ public void setTriggerAction(Collection triggerAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2529,10 +2528,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2555,10 +2554,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2581,10 +2580,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TransitionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl.java b/app/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl.java index b665296a..0567d118 100644 --- a/app/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "TriggerInvocationExpression") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class TriggerInvocationExpressionImpl extends SysMLTypeImpl implements TriggerInvocationExpression { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "TriggerInvocationExpression_aliasId", - joinColumns = @JoinColumn(name = "TriggerInvocationExpressionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "TriggerInvocationExpression_aliasIds", + joinColumns = @JoinColumn(name = "TriggerInvocationExpression_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_argument", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getArgument() { if (argument == null) { argument = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setArgument(List argument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "TriggerInvocationExpression") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "TriggerInvocationExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "TriggerInvocationExpression") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "TriggerInvocationExpression") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "TriggerInvocationExpression") public Function getFunction() { return function; } @@ -406,40 +423,6 @@ public void setFunction(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 = "TriggerInvocationExpression") - 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 = "TriggerInvocationExpression") - 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; @@ -447,10 +430,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -473,10 +456,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -499,10 +482,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -767,10 +750,10 @@ public void setKind(TriggerKind kind) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -793,10 +776,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -819,8 +802,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "TriggerInvocationExpression") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "TriggerInvocationExpression") public Multiplicity getMultiplicity() { return multiplicity; } @@ -833,14 +816,12 @@ public void setMultiplicity(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 = "TriggerInvocationExpression") public String getName() { return name; @@ -860,10 +841,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -886,10 +867,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -912,8 +893,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "TriggerInvocationExpression") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "TriggerInvocationExpression") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -933,10 +914,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -959,10 +940,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -985,10 +966,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1011,10 +992,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1037,10 +1018,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1063,10 +1044,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1089,10 +1070,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1115,10 +1096,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1141,10 +1122,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1167,10 +1148,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1191,10 +1172,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1217,10 +1198,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1243,10 +1224,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1269,10 +1250,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1295,10 +1276,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1321,8 +1302,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "TriggerInvocationExpression") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "TriggerInvocationExpression") public Element getOwner() { return owner; } @@ -1340,8 +1321,8 @@ 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 = "TriggerInvocationExpression") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "TriggerInvocationExpression") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -1355,19 +1336,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "TriggerInvocationExpression") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "TriggerInvocationExpression") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1380,8 +1361,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "TriggerInvocationExpression") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "TriggerInvocationExpression") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1399,8 +1380,8 @@ 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 = "TriggerInvocationExpression") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "TriggerInvocationExpression") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1420,8 +1401,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "TriggerInvocationExpression") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "TriggerInvocationExpression") public Type getOwningType() { return owningType; } @@ -1441,10 +1422,10 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1487,8 +1468,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "TriggerInvocationExpression") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "TriggerInvocationExpression") public Feature getResult() { return result; } @@ -1501,6 +1482,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "TriggerInvocationExpression") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1508,10 +1507,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1534,10 +1533,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TriggerInvocationExpression_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/TypeFeaturingImpl.java b/app/org/omg/sysml/metamodel/impl/TypeFeaturingImpl.java index dc6be86c..8f4e3fd8 100644 --- a/app/org/omg/sysml/metamodel/impl/TypeFeaturingImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TypeFeaturingImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "TypeFeaturing") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class TypeFeaturingImpl extends SysMLTypeImpl implements TypeFeaturing { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "TypeFeaturing_aliasId", - joinColumns = @JoinColumn(name = "TypeFeaturingId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "TypeFeaturing_aliasIds", + joinColumns = @JoinColumn(name = "TypeFeaturing_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -138,13 +139,29 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "TypeFeaturing") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Column("featureOfType") private Feature featureOfType; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "TypeFeaturing") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "TypeFeaturing") public Feature getFeatureOfType() { return featureOfType; } @@ -162,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "TypeFeaturing") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "TypeFeaturing") public Type getFeaturingType() { return featuringType; } @@ -176,48 +193,12 @@ public void setFeaturingType(Type featuringType) { - // @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 = "TypeFeaturing") - 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 = "TypeFeaturing") - 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("name") private String name; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient @javax.persistence.Column(name = "name", table = "TypeFeaturing") public String getName() { return name; @@ -237,10 +218,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -263,10 +244,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -287,10 +268,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -311,10 +292,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -337,8 +318,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "TypeFeaturing") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "TypeFeaturing") public Element getOwner() { return owner; } @@ -358,8 +339,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "TypeFeaturing") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "TypeFeaturing") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -373,19 +354,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "TypeFeaturing") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "TypeFeaturing") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -398,8 +379,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "TypeFeaturing") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "TypeFeaturing") public Namespace getOwningNamespace() { return owningNamespace; } @@ -417,8 +398,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "TypeFeaturing") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "TypeFeaturing") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -436,8 +417,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "TypeFeaturing") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "TypeFeaturing") public Relationship getOwningRelationship() { return owningRelationship; } @@ -477,10 +458,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -496,15 +477,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "TypeFeaturing") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -525,10 +524,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -551,10 +550,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "TypeFeaturing_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/TypeImpl.java b/app/org/omg/sysml/metamodel/impl/TypeImpl.java index bcc35fb9..ce0fa1a1 100644 --- a/app/org/omg/sysml/metamodel/impl/TypeImpl.java +++ b/app/org/omg/sysml/metamodel/impl/TypeImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Type") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class TypeImpl extends SysMLTypeImpl implements Type { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Type_aliasId", - joinColumns = @JoinColumn(name = "TypeId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Type_aliasIds", + joinColumns = @JoinColumn(name = "Type_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -164,6 +165,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Type") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -171,10 +188,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -197,10 +214,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -242,40 +259,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "Type") - 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 = "Type") - 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; @@ -283,10 +266,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -309,10 +292,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -437,10 +420,10 @@ public void setIsSufficient(Boolean isSufficient) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -463,10 +446,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -489,8 +472,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Type") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Type") public Multiplicity getMultiplicity() { return multiplicity; } @@ -503,14 +486,12 @@ public void setMultiplicity(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 = "Type") public String getName() { return name; @@ -530,10 +511,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -556,10 +537,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -582,8 +563,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Type") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Type") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -603,10 +584,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -629,10 +610,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -655,10 +636,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -681,10 +662,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -707,10 +688,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -733,10 +714,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -759,10 +740,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -785,10 +766,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -861,8 +842,8 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Type") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Type") public Element getOwner() { return owner; } @@ -876,19 +857,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Type") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Type") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -901,8 +882,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Type") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Type") public Namespace getOwningNamespace() { return owningNamespace; } @@ -920,8 +901,8 @@ 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 = "Type") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Type") public Relationship getOwningRelationship() { return owningRelationship; } @@ -954,6 +935,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Type") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -961,10 +960,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Type_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/UsageImpl.java b/app/org/omg/sysml/metamodel/impl/UsageImpl.java index 1843f355..e496e5d6 100644 --- a/app/org/omg/sysml/metamodel/impl/UsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/UsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "Usage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class UsageImpl extends SysMLTypeImpl implements Usage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "Usage_aliasId", - joinColumns = @JoinColumn(name = "UsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "Usage_aliasIds", + joinColumns = @JoinColumn(name = "Usage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "Usage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "Usage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "Usage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -385,40 +402,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "Usage") - 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 = "Usage") - 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; @@ -426,10 +409,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -452,10 +435,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -478,10 +461,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -504,10 +487,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -744,10 +727,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -770,10 +753,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -796,8 +779,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "Usage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "Usage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -810,14 +793,12 @@ public void setMultiplicity(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 = "Usage") public String getName() { return name; @@ -837,10 +818,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -863,10 +844,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -889,10 +870,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -915,10 +896,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -941,10 +922,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -967,10 +948,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -993,10 +974,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1019,10 +1000,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1045,10 +1026,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1071,10 +1052,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1097,10 +1078,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1123,10 +1104,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1149,10 +1130,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1175,10 +1156,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1201,10 +1182,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1227,10 +1208,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1253,10 +1234,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1279,10 +1260,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1305,10 +1286,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1331,10 +1312,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1357,10 +1338,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1383,10 +1364,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1409,10 +1390,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1435,10 +1416,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1461,10 +1442,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1487,10 +1468,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1513,10 +1494,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1539,10 +1520,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1565,8 +1546,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "Usage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "Usage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1586,10 +1567,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1612,10 +1593,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1638,10 +1619,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1664,10 +1645,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1690,10 +1671,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1716,10 +1697,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1742,10 +1723,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1768,10 +1749,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1794,10 +1775,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1820,10 +1801,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1844,10 +1825,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1870,10 +1851,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1896,10 +1877,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -1922,10 +1903,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -1948,10 +1929,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -1974,8 +1955,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "Usage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "Usage") public Element getOwner() { return owner; } @@ -1995,8 +1976,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "Usage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "Usage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2014,8 +1995,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "Usage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "Usage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2029,19 +2010,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "Usage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "Usage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2054,8 +2035,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "Usage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "Usage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2073,8 +2054,8 @@ 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 = "Usage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "Usage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2094,8 +2075,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "Usage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "Usage") public Type getOwningType() { return owningType; } @@ -2115,8 +2096,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "Usage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "Usage") public Usage getOwningUsage() { return owningUsage; } @@ -2149,6 +2130,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "Usage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2156,10 +2155,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2182,10 +2181,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2208,10 +2207,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2234,10 +2233,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2260,10 +2259,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "Usage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl.java index 15c9401d..ea161efe 100644 --- a/app/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class UseCaseDefinitionImpl extends SysMLTypeImpl implements UseCaseDefin @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setAction(List action) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "UseCaseDefinition_aliasId", - joinColumns = @JoinColumn(name = "UseCaseDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "UseCaseDefinition_aliasIds", + joinColumns = @JoinColumn(name = "UseCaseDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_calculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getCalculation() { if (calculation == null) { calculation = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setCalculation(List calculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -268,6 +269,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "UseCaseDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -275,10 +292,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -372,40 +389,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "UseCaseDefinition") - 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 = "UseCaseDefinition") - 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; @@ -413,10 +396,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_includedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getIncludedUseCase() { if (includedUseCase == null) { includedUseCase = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setIncludedUseCase(List includedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -517,10 +500,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -643,8 +626,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "UseCaseDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "UseCaseDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -664,10 +647,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -690,10 +673,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -716,8 +699,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "UseCaseDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "UseCaseDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -730,14 +713,12 @@ public void setMultiplicity(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 = "UseCaseDefinition") public String getName() { return name; @@ -757,8 +738,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "UseCaseDefinition") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "UseCaseDefinition") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -778,10 +759,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -804,10 +785,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -830,10 +811,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -856,10 +837,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -882,10 +863,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -908,10 +889,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -934,10 +915,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -960,10 +941,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -986,10 +967,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -1012,8 +993,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "UseCaseDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "UseCaseDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1033,10 +1014,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1059,10 +1040,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1499,10 +1480,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1525,10 +1506,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1551,10 +1532,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1577,10 +1558,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1603,10 +1584,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1629,10 +1610,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1655,10 +1636,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1681,10 +1662,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1707,10 +1688,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1733,10 +1714,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1759,10 +1740,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1785,10 +1766,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1811,8 +1792,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "UseCaseDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "UseCaseDefinition") public Element getOwner() { return owner; } @@ -1826,19 +1807,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "UseCaseDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "UseCaseDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1851,8 +1832,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "UseCaseDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "UseCaseDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1870,8 +1851,8 @@ 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 = "UseCaseDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "UseCaseDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1891,10 +1872,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1937,8 +1918,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "UseCaseDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "UseCaseDefinition") public Feature getResult() { return result; } @@ -1951,6 +1932,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "UseCaseDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1958,10 +1957,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1984,8 +1983,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "UseCaseDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "UseCaseDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -2005,10 +2004,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2031,10 +2030,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2057,10 +2056,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2083,10 +2082,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/UseCaseUsageImpl.java b/app/org/omg/sysml/metamodel/impl/UseCaseUsageImpl.java index 692d83c9..9e0cbc5c 100644 --- a/app/org/omg/sysml/metamodel/impl/UseCaseUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/UseCaseUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class UseCaseUsageImpl extends SysMLTypeImpl implements UseCaseUsage { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setActionDefinition(List actionDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "UseCaseUsage_aliasId", - joinColumns = @JoinColumn(name = "UseCaseUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "UseCaseUsage_aliasIds", + joinColumns = @JoinColumn(name = "UseCaseUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,8 +178,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "calculationDefinitionId", table = "UseCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "calculationDefinition_id", table = "UseCaseUsage") public Function getCalculationDefinition() { return calculationDefinition; } @@ -198,8 +199,8 @@ public void setCalculationDefinition(Function calculationDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "caseDefinitionId", table = "UseCaseUsage") + @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "caseDefinition_id", table = "UseCaseUsage") public CaseDefinition getCaseDefinition() { return caseDefinition; } @@ -219,10 +220,10 @@ public void setCaseDefinition(CaseDefinition caseDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -245,10 +246,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -297,10 +298,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -341,10 +342,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -380,6 +381,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "UseCaseUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -387,10 +404,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -413,8 +430,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "UseCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "UseCaseUsage") public Type getEndOwningType() { return endOwningType; } @@ -434,10 +451,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -460,10 +477,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -486,10 +503,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -512,8 +529,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "UseCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "UseCaseUsage") public Function getFunction() { return function; } @@ -526,40 +543,6 @@ public void setFunction(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 = "UseCaseUsage") - 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 = "UseCaseUsage") - 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; @@ -567,10 +550,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -593,10 +576,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_includedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getIncludedUseCase() { if (includedUseCase == null) { includedUseCase = new ArrayList<>(); @@ -619,8 +602,8 @@ public void setIncludedUseCase(List includedUseCase) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "UseCaseUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "UseCaseUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -640,10 +623,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -666,10 +649,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -692,10 +675,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -966,10 +949,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -992,10 +975,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -1018,8 +1001,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "UseCaseUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "UseCaseUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1032,14 +1015,12 @@ public void setMultiplicity(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 = "UseCaseUsage") public String getName() { return name; @@ -1059,10 +1040,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1605,10 +1586,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1631,10 +1612,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1657,10 +1638,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1683,10 +1664,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1709,10 +1690,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1735,8 +1716,8 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "UseCaseUsage") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "UseCaseUsage") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -1756,10 +1737,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1782,10 +1763,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1808,10 +1789,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1834,8 +1815,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "UseCaseUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "UseCaseUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1855,10 +1836,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1881,10 +1862,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1907,10 +1888,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2089,10 +2070,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2113,10 +2094,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2139,10 +2120,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2165,10 +2146,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2191,10 +2172,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2217,10 +2198,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2243,8 +2224,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "UseCaseUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "UseCaseUsage") public Element getOwner() { return owner; } @@ -2264,8 +2245,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "UseCaseUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "UseCaseUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2283,8 +2264,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "UseCaseUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "UseCaseUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2298,19 +2279,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "UseCaseUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "UseCaseUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2323,8 +2304,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "UseCaseUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "UseCaseUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2342,8 +2323,8 @@ 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 = "UseCaseUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "UseCaseUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2363,8 +2344,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "UseCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "UseCaseUsage") public Type getOwningType() { return owningType; } @@ -2384,8 +2365,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "UseCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "UseCaseUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2405,10 +2386,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2449,8 +2430,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "UseCaseUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "UseCaseUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2490,8 +2471,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "UseCaseUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "UseCaseUsage") public Feature getResult() { return result; } @@ -2504,6 +2485,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "UseCaseUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("subjectParameter") private Usage subjectParameter; @@ -2511,8 +2510,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "UseCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "UseCaseUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2532,10 +2531,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2558,10 +2557,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2584,10 +2583,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2610,8 +2609,8 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UseCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "useCaseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "useCaseDefinitionId", table = "UseCaseUsage") + @Any(metaDef = "UseCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "useCaseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "useCaseDefinition_id", table = "UseCaseUsage") public UseCaseDefinition getUseCaseDefinition() { return useCaseDefinition; } @@ -2631,10 +2630,10 @@ public void setUseCaseDefinition(UseCaseDefinition useCaseDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2657,10 +2656,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "UseCaseUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/VariantMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/VariantMembershipImpl.java index 095dced6..cd45f6d4 100644 --- a/app/org/omg/sysml/metamodel/impl/VariantMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/VariantMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "VariantMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class VariantMembershipImpl extends SysMLTypeImpl implements VariantMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "VariantMembership_aliasId", - joinColumns = @JoinColumn(name = "VariantMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "VariantMembership_aliasIds", + joinColumns = @JoinColumn(name = "VariantMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -118,26 +119,6 @@ public void setDocumentation(List documentation) { - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; - - @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveMemberName", table = "VariantMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; - } - - @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; - } - - - // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("effectiveName") private String effectiveName; @@ -158,55 +139,57 @@ public void setEffectiveName(String effectiveName) { - // @info.archinnov.achilles.annotations.Column("humanId") - private String humanId; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - @javax.persistence.Column(name = "humanId", table = "VariantMembership") - public String getHumanId() { - return humanId; + @javax.persistence.Column(name = "elementId", table = "VariantMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setHumanId(String humanId) { - this.humanId = humanId; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } - // @info.archinnov.achilles.annotations.Column("identifier") - private java.util.UUID identifier; + // @info.archinnov.achilles.annotations.Column("memberElement") + private Element memberElement; @JsonGetter - @javax.persistence.Column(name = "identifier", table = "VariantMembership") - public java.util.UUID getIdentifier() { - return identifier; + @JsonSerialize(using = DataSerializer.class) + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "VariantMembership") + public Element getMemberElement() { + return memberElement; } @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; + @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) + public void setMemberElement(Element memberElement) { + this.memberElement = memberElement; } - // @info.archinnov.achilles.annotations.Column("memberElement") - private Element memberElement; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "VariantMembership") - public Element getMemberElement() { - return memberElement; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "VariantMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = ElementImpl.class) - public void setMemberElement(Element memberElement) { - this.memberElement = memberElement; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -229,6 +212,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "VariantMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -236,8 +237,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "VariantMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "VariantMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -250,14 +251,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "VariantMembership") public String getName() { return name; @@ -277,10 +276,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -303,10 +302,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -327,8 +326,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "VariantMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "VariantMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -341,15 +340,75 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "VariantMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "VariantMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "VariantMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -370,10 +429,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -394,8 +453,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedVariantUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedVariantUsageId", table = "VariantMembership") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedVariantUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedVariantUsage_id", table = "VariantMembership") public Usage getOwnedVariantUsage() { return ownedVariantUsage; } @@ -415,8 +474,8 @@ public void setOwnedVariantUsage(Usage ownedVariantUsage) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "VariantMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "VariantMembership") public Element getOwner() { return owner; } @@ -430,19 +489,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "VariantMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "VariantMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -455,8 +514,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "VariantMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "VariantMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -474,8 +533,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "VariantMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "VariantMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -493,8 +552,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "VariantMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "VariantMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -534,10 +593,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -553,15 +612,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "VariantMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -582,10 +659,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -608,10 +685,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VariantMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl.java index f9949f76..b6e6d5ae 100644 --- a/app/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class VerificationCaseDefinitionImpl extends SysMLTypeImpl implements Ver @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_action", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAction() { if (action == null) { action = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setAction(List action) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "VerificationCaseDefinition_aliasId", - joinColumns = @JoinColumn(name = "VerificationCaseDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "VerificationCaseDefinition_aliasIds", + joinColumns = @JoinColumn(name = "VerificationCaseDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_calculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getCalculation() { if (calculation == null) { calculation = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setCalculation(List calculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -229,10 +230,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -268,6 +269,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "VerificationCaseDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -275,10 +292,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -372,40 +389,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "VerificationCaseDefinition") - 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 = "VerificationCaseDefinition") - 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; @@ -413,10 +396,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -617,8 +600,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "VerificationCaseDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "VerificationCaseDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -638,10 +621,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -664,10 +647,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -690,8 +673,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "VerificationCaseDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "VerificationCaseDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -704,14 +687,12 @@ public void setMultiplicity(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 = "VerificationCaseDefinition") public String getName() { return name; @@ -731,8 +712,8 @@ public void setName(String name) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "VerificationCaseDefinition") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "VerificationCaseDefinition") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -752,10 +733,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -778,10 +759,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -804,10 +785,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -830,10 +811,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -856,10 +837,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -882,10 +863,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -908,10 +889,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -934,10 +915,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -960,10 +941,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -986,8 +967,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "VerificationCaseDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "VerificationCaseDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1007,10 +988,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1033,10 +1014,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1059,10 +1040,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1473,10 +1454,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1499,10 +1480,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1525,10 +1506,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1551,10 +1532,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1577,10 +1558,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1603,10 +1584,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1629,10 +1610,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1655,10 +1636,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1681,10 +1662,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1707,10 +1688,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1733,10 +1714,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1759,10 +1740,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1785,8 +1766,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "VerificationCaseDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "VerificationCaseDefinition") public Element getOwner() { return owner; } @@ -1800,19 +1781,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "VerificationCaseDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "VerificationCaseDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1825,8 +1806,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "VerificationCaseDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "VerificationCaseDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1844,8 +1825,8 @@ 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 = "VerificationCaseDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "VerificationCaseDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1865,10 +1846,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1911,8 +1892,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "VerificationCaseDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "VerificationCaseDefinition") public Feature getResult() { return result; } @@ -1925,6 +1906,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "VerificationCaseDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("step") private Collection step; @@ -1932,10 +1931,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -1958,8 +1957,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "VerificationCaseDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "VerificationCaseDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -1979,10 +1978,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2005,10 +2004,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2031,10 +2030,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2057,10 +2056,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -2083,10 +2082,10 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseDefinition_verifiedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getVerifiedRequirement() { if (verifiedRequirement == null) { verifiedRequirement = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl.java b/app/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl.java index bba5e772..814d16d3 100644 --- a/app/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class VerificationCaseUsageImpl extends SysMLTypeImpl implements Verifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -102,10 +103,10 @@ public void setActionDefinition(List actionDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -121,25 +122,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "VerificationCaseUsage_aliasId", - joinColumns = @JoinColumn(name = "VerificationCaseUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "VerificationCaseUsage_aliasIds", + joinColumns = @JoinColumn(name = "VerificationCaseUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -151,10 +152,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,8 +178,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "calculationDefinitionId", table = "VerificationCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "calculationDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "calculationDefinition_id", table = "VerificationCaseUsage") public Function getCalculationDefinition() { return calculationDefinition; } @@ -198,8 +199,8 @@ public void setCalculationDefinition(Function calculationDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "caseDefinitionId", table = "VerificationCaseUsage") + @Any(metaDef = "CaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "caseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "caseDefinition_id", table = "VerificationCaseUsage") public CaseDefinition getCaseDefinition() { return caseDefinition; } @@ -219,10 +220,10 @@ public void setCaseDefinition(CaseDefinition caseDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -245,10 +246,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -271,10 +272,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -297,10 +298,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -341,10 +342,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -380,6 +381,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "VerificationCaseUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -387,10 +404,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -413,8 +430,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "VerificationCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "VerificationCaseUsage") public Type getEndOwningType() { return endOwningType; } @@ -434,10 +451,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -460,10 +477,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -486,10 +503,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -512,8 +529,8 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "VerificationCaseUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "VerificationCaseUsage") public Function getFunction() { return function; } @@ -526,40 +543,6 @@ public void setFunction(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 = "VerificationCaseUsage") - 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 = "VerificationCaseUsage") - 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; @@ -567,10 +550,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -593,8 +576,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "VerificationCaseUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "VerificationCaseUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -614,10 +597,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -640,10 +623,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -666,10 +649,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -940,10 +923,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -966,10 +949,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -992,8 +975,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "VerificationCaseUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "VerificationCaseUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1006,14 +989,12 @@ public void setMultiplicity(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 = "VerificationCaseUsage") public String getName() { return name; @@ -1033,10 +1014,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1059,10 +1040,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1085,10 +1066,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1111,10 +1092,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1137,10 +1118,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1163,10 +1144,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1189,10 +1170,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1215,10 +1196,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1241,10 +1222,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1267,10 +1248,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1293,10 +1274,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1319,10 +1300,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1345,10 +1326,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1371,10 +1352,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1397,10 +1378,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1423,10 +1404,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1449,10 +1430,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1475,10 +1456,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1501,10 +1482,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1527,10 +1508,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1553,10 +1534,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1579,10 +1560,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1605,10 +1586,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1631,10 +1612,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1657,10 +1638,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1683,10 +1664,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1709,8 +1690,8 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "objectiveRequirementId", table = "VerificationCaseUsage") + @Any(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "objectiveRequirement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "objectiveRequirement_id", table = "VerificationCaseUsage") public RequirementUsage getObjectiveRequirement() { return objectiveRequirement; } @@ -1730,10 +1711,10 @@ public void setObjectiveRequirement(RequirementUsage objectiveRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1756,10 +1737,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1782,10 +1763,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1808,8 +1789,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "VerificationCaseUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "VerificationCaseUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1829,10 +1810,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1855,10 +1836,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1881,10 +1862,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1907,10 +1888,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1933,10 +1914,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2087,10 +2068,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2113,10 +2094,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2139,10 +2120,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2165,10 +2146,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2191,10 +2172,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2217,8 +2198,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "VerificationCaseUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "VerificationCaseUsage") public Element getOwner() { return owner; } @@ -2238,8 +2219,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "VerificationCaseUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "VerificationCaseUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2257,8 +2238,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "VerificationCaseUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "VerificationCaseUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2272,19 +2253,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "VerificationCaseUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "VerificationCaseUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2297,8 +2278,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "VerificationCaseUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "VerificationCaseUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2316,8 +2297,8 @@ 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 = "VerificationCaseUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "VerificationCaseUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2337,8 +2318,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "VerificationCaseUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "VerificationCaseUsage") public Type getOwningType() { return owningType; } @@ -2358,8 +2339,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "VerificationCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "VerificationCaseUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2379,10 +2360,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2423,8 +2404,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "VerificationCaseUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "VerificationCaseUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2464,8 +2445,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "VerificationCaseUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "VerificationCaseUsage") public Feature getResult() { return result; } @@ -2478,6 +2459,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "VerificationCaseUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("subjectParameter") private Usage subjectParameter; @@ -2485,8 +2484,8 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "VerificationCaseUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "VerificationCaseUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2506,10 +2505,10 @@ public void setSubjectParameter(Usage subjectParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2532,10 +2531,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2558,10 +2557,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2584,10 +2583,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2610,10 +2609,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -2636,8 +2635,8 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "VerificationCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "verificationCaseDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "verificationCaseDefinitionId", table = "VerificationCaseUsage") + @Any(metaDef = "VerificationCaseDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "verificationCaseDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "verificationCaseDefinition_id", table = "VerificationCaseUsage") public VerificationCaseDefinition getVerificationCaseDefinition() { return verificationCaseDefinition; } @@ -2657,10 +2656,10 @@ public void setVerificationCaseDefinition(VerificationCaseDefinition verificatio @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "VerificationCaseUsage_verifiedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getVerifiedRequirement() { if (verifiedRequirement == null) { verifiedRequirement = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ViewDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ViewDefinitionImpl.java index 350c8d14..d68ef123 100644 --- a/app/org/omg/sysml/metamodel/impl/ViewDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ViewDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ViewDefinition") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ViewDefinitionImpl extends SysMLTypeImpl implements ViewDefinition { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ViewDefinition_aliasId", - joinColumns = @JoinColumn(name = "ViewDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ViewDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ViewDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -190,6 +191,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ViewDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -197,10 +214,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -223,10 +240,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -249,10 +266,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -268,40 +285,6 @@ public void setFeatureMembership(List featureMembership) { - // @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 = "ViewDefinition") - 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 = "ViewDefinition") - 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; @@ -309,10 +292,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -335,10 +318,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -361,10 +344,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -387,10 +370,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -495,8 +478,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ViewDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ViewDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -516,10 +499,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -542,10 +525,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -568,8 +551,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ViewDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ViewDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -582,14 +565,12 @@ public void setMultiplicity(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 = "ViewDefinition") public String getName() { return name; @@ -609,10 +590,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -635,10 +616,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -661,10 +642,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -687,10 +668,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -713,10 +694,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -739,10 +720,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -765,10 +746,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -791,10 +772,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -817,10 +798,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -843,8 +824,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ViewDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ViewDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -864,10 +845,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -890,10 +871,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -916,10 +897,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -942,10 +923,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -968,10 +949,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -994,10 +975,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1020,10 +1001,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1046,10 +1027,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1072,10 +1053,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1098,10 +1079,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1124,10 +1105,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1150,10 +1131,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1176,10 +1157,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1202,10 +1183,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1228,10 +1209,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1254,10 +1235,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1280,10 +1261,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1306,10 +1287,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1330,10 +1311,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1356,10 +1337,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1382,10 +1363,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1408,10 +1389,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1434,10 +1415,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1460,10 +1441,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1486,10 +1467,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1512,10 +1493,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1538,10 +1519,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1564,10 +1545,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1590,10 +1571,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1616,10 +1597,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1642,8 +1623,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ViewDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ViewDefinition") public Element getOwner() { return owner; } @@ -1657,19 +1638,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ViewDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ViewDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1682,8 +1663,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ViewDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ViewDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1701,8 +1682,8 @@ 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 = "ViewDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ViewDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1742,10 +1723,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_satisfiedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSatisfiedViewpoint() { if (satisfiedViewpoint == null) { satisfiedViewpoint = new ArrayList<>(); @@ -1761,6 +1742,24 @@ public void setSatisfiedViewpoint(List satisfiedViewpoint) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ViewDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -1768,10 +1767,10 @@ public void setSatisfiedViewpoint(List satisfiedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -1794,10 +1793,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -1820,10 +1819,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -1846,10 +1845,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -1872,10 +1871,10 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_view", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getView() { if (view == null) { view = new ArrayList<>(); @@ -1898,10 +1897,10 @@ public void setView(List view) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewDefinition_viewCondition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getViewCondition() { if (viewCondition == null) { viewCondition = new ArrayList<>(); @@ -1924,8 +1923,8 @@ public void setViewCondition(List viewCondition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "viewRenderingType"), fetch = FetchType.LAZY) - @JoinColumn(name = "viewRenderingId", table = "ViewDefinition") + @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "viewRendering_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "viewRendering_id", table = "ViewDefinition") public RenderingUsage getViewRendering() { return viewRendering; } diff --git a/app/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl.java b/app/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl.java index b71bc3fc..a3d97688 100644 --- a/app/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ViewRenderingMembership") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ViewRenderingMembershipImpl extends SysMLTypeImpl implements ViewRenderingMembership { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ViewRenderingMembership_aliasId", - joinColumns = @JoinColumn(name = "ViewRenderingMembershipId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ViewRenderingMembership_aliasIds", + joinColumns = @JoinColumn(name = "ViewRenderingMembership_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -119,41 +120,37 @@ public void setDocumentation(List documentation) { // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveMemberName") - private String effectiveMemberName; + // @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 = "effectiveMemberName", table = "ViewRenderingMembership") - public String getEffectiveMemberName() { - return effectiveMemberName; + @javax.persistence.Column(name = "effectiveName", table = "ViewRenderingMembership") + public String getEffectiveName() { + return effectiveName; } @JsonSetter - public void setEffectiveMemberName(String effectiveMemberName) { - this.effectiveMemberName = effectiveMemberName; + public void setEffectiveName(String effectiveName) { + this.effectiveName = effectiveName; } - // @info.archinnov.achilles.annotations.Transient - // @info.archinnov.achilles.annotations.Column("effectiveName") - private String effectiveName; + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; @JsonGetter - @Lob - @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") - // @javax.persistence.Transient - @javax.persistence.Column(name = "effectiveName", table = "ViewRenderingMembership") - public String getEffectiveName() { - return effectiveName; + @javax.persistence.Column(name = "elementId", table = "ViewRenderingMembership") + public java.util.UUID getElementId() { + return elementId; } @JsonSetter - public void setEffectiveName(String effectiveName) { - this.effectiveName = effectiveName; + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; } @@ -163,8 +160,8 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featureOfTypeId", table = "ViewRenderingMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "featureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featureOfType_id", table = "ViewRenderingMembership") public Feature getFeatureOfType() { return featureOfType; } @@ -182,8 +179,8 @@ public void setFeatureOfType(Feature featureOfType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "featuringTypeId", table = "ViewRenderingMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "featuringType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "featuringType_id", table = "ViewRenderingMembership") public Type getFeaturingType() { return featuringType; } @@ -196,47 +193,13 @@ public void setFeaturingType(Type featuringType) { - // @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 = "ViewRenderingMembership") - 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 = "ViewRenderingMembership") - public java.util.UUID getIdentifier() { - return identifier; - } - - @JsonSetter - public void setIdentifier(java.util.UUID identifier) { - this.identifier = identifier; - } - - - // @info.archinnov.achilles.annotations.Column("memberElement") private Element memberElement; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberElementId", table = "ViewRenderingMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "memberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "memberElement_id", table = "ViewRenderingMembership") public Element getMemberElement() { return memberElement; } @@ -249,21 +212,22 @@ public void setMemberElement(Element memberElement) { - // @info.archinnov.achilles.annotations.Column("memberFeature") - private Feature memberFeature; + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("memberElementId") + private String memberElementId; @JsonGetter - @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "memberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "memberFeatureId", table = "ViewRenderingMembership") - public Feature getMemberFeature() { - return memberFeature; + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "memberElementId", table = "ViewRenderingMembership") + public String getMemberElementId() { + return memberElementId; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = FeatureImpl.class) - public void setMemberFeature(Feature memberFeature) { - this.memberFeature = memberFeature; + public void setMemberElementId(String memberElementId) { + this.memberElementId = memberElementId; } @@ -286,6 +250,24 @@ public void setMemberName(String memberName) { + // @info.archinnov.achilles.annotations.Column("memberShortName") + private String memberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "memberShortName", table = "ViewRenderingMembership") + public String getMemberShortName() { + return memberShortName; + } + + @JsonSetter + public void setMemberShortName(String memberShortName) { + this.memberShortName = memberShortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("membershipOwningNamespace") private Namespace membershipOwningNamespace; @@ -293,8 +275,8 @@ public void setMemberName(String memberName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "membershipOwningNamespaceId", table = "ViewRenderingMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "membershipOwningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "membershipOwningNamespace_id", table = "ViewRenderingMembership") public Namespace getMembershipOwningNamespace() { return membershipOwningNamespace; } @@ -307,14 +289,12 @@ public void setMembershipOwningNamespace(Namespace membershipOwningNamespace) { - // @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 = "ViewRenderingMembership") public String getName() { return name; @@ -334,10 +314,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -360,10 +340,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -384,8 +364,8 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberElementId", table = "ViewRenderingMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberElement_id", table = "ViewRenderingMembership") public Element getOwnedMemberElement() { return ownedMemberElement; } @@ -398,13 +378,33 @@ public void setOwnedMemberElement(Element ownedMemberElement) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberElementId") + private String ownedMemberElementId; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberElementId", table = "ViewRenderingMembership") + public String getOwnedMemberElementId() { + return ownedMemberElementId; + } + + @JsonSetter + public void setOwnedMemberElementId(String ownedMemberElementId) { + this.ownedMemberElementId = ownedMemberElementId; + } + + + // @info.archinnov.achilles.annotations.Column("ownedMemberFeature") private Feature ownedMemberFeature; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedMemberFeatureId", table = "ViewRenderingMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "ownedMemberFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedMemberFeature_id", table = "ViewRenderingMembership") public Feature getOwnedMemberFeature() { return ownedMemberFeature; } @@ -417,15 +417,55 @@ public void setOwnedMemberFeature(Feature ownedMemberFeature) { + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberName") + private String ownedMemberName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberName", table = "ViewRenderingMembership") + public String getOwnedMemberName() { + return ownedMemberName; + } + + @JsonSetter + public void setOwnedMemberName(String ownedMemberName) { + this.ownedMemberName = ownedMemberName; + } + + + + // @info.archinnov.achilles.annotations.Transient + // @info.archinnov.achilles.annotations.Column("ownedMemberShortName") + private String ownedMemberShortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + // @javax.persistence.Transient + @javax.persistence.Column(name = "ownedMemberShortName", table = "ViewRenderingMembership") + public String getOwnedMemberShortName() { + return ownedMemberShortName; + } + + @JsonSetter + public void setOwnedMemberShortName(String ownedMemberShortName) { + this.ownedMemberShortName = ownedMemberShortName; + } + + + // @info.archinnov.achilles.annotations.Column("ownedRelatedElement") private List ownedRelatedElement; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_ownedRelatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelatedElement() { if (ownedRelatedElement == null) { ownedRelatedElement = new ArrayList<>(); @@ -446,10 +486,10 @@ public void setOwnedRelatedElement(List ownedRelatedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -470,8 +510,8 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedRenderingType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedRenderingId", table = "ViewRenderingMembership") + @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "ownedRendering_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedRendering_id", table = "ViewRenderingMembership") public RenderingUsage getOwnedRendering() { return ownedRendering; } @@ -491,8 +531,8 @@ public void setOwnedRendering(RenderingUsage ownedRendering) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ViewRenderingMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ViewRenderingMembership") public Element getOwner() { return owner; } @@ -512,8 +552,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureOfTypeId", table = "ViewRenderingMembership") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureOfType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureOfType_id", table = "ViewRenderingMembership") public Feature getOwningFeatureOfType() { return owningFeatureOfType; } @@ -527,19 +567,19 @@ public void setOwningFeatureOfType(Feature owningFeatureOfType) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ViewRenderingMembership") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ViewRenderingMembership") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -552,8 +592,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ViewRenderingMembership") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ViewRenderingMembership") public Namespace getOwningNamespace() { return owningNamespace; } @@ -571,8 +611,8 @@ public void setOwningNamespace(Namespace owningNamespace) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElementType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelatedElementId", table = "ViewRenderingMembership") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelatedElement_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelatedElement_id", table = "ViewRenderingMembership") public Element getOwningRelatedElement() { return owningRelatedElement; } @@ -590,8 +630,8 @@ public void setOwningRelatedElement(Element owningRelatedElement) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationshipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningRelationshipId", table = "ViewRenderingMembership") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ViewRenderingMembership") public Relationship getOwningRelationship() { return owningRelationship; } @@ -611,8 +651,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ViewRenderingMembership") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ViewRenderingMembership") public Type getOwningType() { return owningType; } @@ -652,8 +692,8 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedRenderingType"), fetch = FetchType.LAZY) - @JoinColumn(name = "referencedRenderingId", table = "ViewRenderingMembership") + @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "referencedRendering_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "referencedRendering_id", table = "ViewRenderingMembership") public RenderingUsage getReferencedRendering() { return referencedRendering; } @@ -673,10 +713,10 @@ public void setReferencedRendering(RenderingUsage referencedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_relatedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRelatedElement() { if (relatedElement == null) { relatedElement = new ArrayList<>(); @@ -692,15 +732,33 @@ public void setRelatedElement(List relatedElement) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ViewRenderingMembership") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Column("source") private List source; @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_source", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSource() { if (source == null) { source = new ArrayList<>(); @@ -721,10 +779,10 @@ public void setSource(List source) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_target", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTarget() { if (target == null) { target = new ArrayList<>(); @@ -747,10 +805,10 @@ public void setTarget(List target) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewRenderingMembership_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ViewUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ViewUsageImpl.java index 5560091d..d8f1f013 100644 --- a/app/org/omg/sysml/metamodel/impl/ViewUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ViewUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -69,25 +70,25 @@ @JsonTypeName(value = "ViewUsage") @JsonTypeInfo(use = JsonTypeInfo.Id.NAME) public class ViewUsageImpl extends SysMLTypeImpl implements ViewUsage { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ViewUsage_aliasId", - joinColumns = @JoinColumn(name = "ViewUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ViewUsage_aliasIds", + joinColumns = @JoinColumn(name = "ViewUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -99,10 +100,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -125,10 +126,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -221,10 +222,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -260,6 +261,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ViewUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -267,10 +284,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -293,8 +310,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ViewUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ViewUsage") public Type getEndOwningType() { return endOwningType; } @@ -314,10 +331,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_exposedNamespace", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getExposedNamespace() { if (exposedNamespace == null) { exposedNamespace = new ArrayList<>(); @@ -340,10 +357,10 @@ public void setExposedNamespace(List exposedNamespace) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -366,10 +383,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -392,10 +409,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -411,40 +428,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "ViewUsage") - 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 = "ViewUsage") - 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; @@ -452,10 +435,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -478,8 +461,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ViewUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ViewUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -499,10 +482,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -525,10 +508,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -551,10 +534,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -807,10 +790,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StructureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_itemDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getItemDefinition() { if (itemDefinition == null) { itemDefinition = new ArrayList<>(); @@ -833,10 +816,10 @@ public void setItemDefinition(List itemDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -859,10 +842,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -885,8 +868,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ViewUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ViewUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -899,14 +882,12 @@ public void setMultiplicity(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 = "ViewUsage") public String getName() { return name; @@ -926,10 +907,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -952,10 +933,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -978,10 +959,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1004,10 +985,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1030,10 +1011,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1056,10 +1037,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1082,10 +1063,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1108,10 +1089,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1134,10 +1115,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1160,10 +1141,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1186,10 +1167,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1212,10 +1193,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1238,10 +1219,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1264,10 +1245,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1290,10 +1271,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1316,10 +1297,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1342,10 +1323,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1368,10 +1349,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1394,10 +1375,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1420,10 +1401,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1446,10 +1427,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1472,10 +1453,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1498,10 +1479,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1524,10 +1505,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1550,10 +1531,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1576,10 +1557,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1602,10 +1583,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1628,10 +1609,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1654,10 +1635,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1680,8 +1661,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ViewUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ViewUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1701,10 +1682,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1727,10 +1708,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1753,10 +1734,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1779,10 +1760,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1805,10 +1786,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1831,10 +1812,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1857,10 +1838,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1883,10 +1864,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1909,10 +1890,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1935,10 +1916,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1959,10 +1940,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1985,10 +1966,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2011,10 +1992,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2037,10 +2018,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2063,10 +2044,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2089,8 +2070,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ViewUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ViewUsage") public Element getOwner() { return owner; } @@ -2110,8 +2091,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ViewUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ViewUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2129,8 +2110,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ViewUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ViewUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2144,19 +2125,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ViewUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ViewUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2169,8 +2150,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ViewUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ViewUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2188,8 +2169,8 @@ 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 = "ViewUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ViewUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2209,8 +2190,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ViewUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ViewUsage") public Type getOwningType() { return owningType; } @@ -2230,8 +2211,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ViewUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ViewUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2251,10 +2232,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_partDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getPartDefinition() { if (partDefinition == null) { partDefinition = new ArrayList<>(); @@ -2295,8 +2276,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ViewUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ViewUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2336,10 +2317,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_satisfiedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getSatisfiedViewpoint() { if (satisfiedViewpoint == null) { satisfiedViewpoint = new ArrayList<>(); @@ -2355,6 +2336,24 @@ public void setSatisfiedViewpoint(List satisfiedViewpoint) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ViewUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2362,10 +2361,10 @@ public void setSatisfiedViewpoint(List satisfiedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2388,10 +2387,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2414,10 +2413,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2440,10 +2439,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2466,10 +2465,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -2492,10 +2491,10 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_viewCondition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getViewCondition() { if (viewCondition == null) { viewCondition = new ArrayList<>(); @@ -2518,8 +2517,8 @@ public void setViewCondition(List viewCondition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ViewDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "viewDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "viewDefinitionId", table = "ViewUsage") + @Any(metaDef = "ViewDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "viewDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "viewDefinition_id", table = "ViewUsage") public ViewDefinition getViewDefinition() { return viewDefinition; } @@ -2539,8 +2538,8 @@ public void setViewDefinition(ViewDefinition viewDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "viewRenderingType"), fetch = FetchType.LAZY) - @JoinColumn(name = "viewRenderingId", table = "ViewUsage") + @Any(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "viewRendering_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "viewRendering_id", table = "ViewUsage") public RenderingUsage getViewRendering() { return viewRendering; } @@ -2560,10 +2559,10 @@ public void setViewRendering(RenderingUsage viewRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewUsage_viewedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getViewedElement() { if (viewedElement == null) { viewedElement = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl.java b/app/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl.java index 3ed56221..5ef1ddcf 100644 --- a/app/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ViewpointDefinitionImpl extends SysMLTypeImpl implements ViewpointD @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ViewpointDefinition_aliasId", - joinColumns = @JoinColumn(name = "ViewpointDefinitionId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ViewpointDefinition_aliasIds", + joinColumns = @JoinColumn(name = "ViewpointDefinition_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -203,10 +204,10 @@ public void setDirectedUsage(List directedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -242,6 +243,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ViewpointDefinition") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -249,10 +266,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -275,10 +292,10 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_expression", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getExpression() { if (expression == null) { expression = new ArrayList<>(); @@ -301,10 +318,10 @@ public void setExpression(Collection expression) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -327,10 +344,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -353,10 +370,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -372,40 +389,6 @@ public void setFramedConcern(List framedConcern) { - // @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 = "ViewpointDefinition") - 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 = "ViewpointDefinition") - 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; @@ -413,10 +396,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -439,10 +422,10 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -465,10 +448,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -491,10 +474,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -617,8 +600,8 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClassType"), fetch = FetchType.LAZY) - @JoinColumn(name = "lifeClassId", table = "ViewpointDefinition") + @Any(metaDef = "LifeClassMetaDef", metaColumn = @javax.persistence.Column(name = "lifeClass_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "lifeClass_id", table = "ViewpointDefinition") public LifeClass getLifeClass() { return lifeClass; } @@ -638,10 +621,10 @@ public void setLifeClass(LifeClass lifeClass) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -664,10 +647,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -690,8 +673,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ViewpointDefinition") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ViewpointDefinition") public Multiplicity getMultiplicity() { return multiplicity; } @@ -704,14 +687,12 @@ public void setMultiplicity(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 = "ViewpointDefinition") public String getName() { return name; @@ -731,10 +712,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -757,10 +738,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAction() { if (ownedAction == null) { ownedAction = new ArrayList<>(); @@ -783,10 +764,10 @@ public void setOwnedAction(List ownedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAllocation() { if (ownedAllocation == null) { ownedAllocation = new ArrayList<>(); @@ -809,10 +790,10 @@ public void setOwnedAllocation(List ownedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnalysisCase() { if (ownedAnalysisCase == null) { ownedAnalysisCase = new ArrayList<>(); @@ -835,10 +816,10 @@ public void setOwnedAnalysisCase(List ownedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -861,10 +842,10 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAttribute() { if (ownedAttribute == null) { ownedAttribute = new ArrayList<>(); @@ -887,10 +868,10 @@ public void setOwnedAttribute(List ownedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCalculation() { if (ownedCalculation == null) { ownedCalculation = new ArrayList<>(); @@ -913,10 +894,10 @@ public void setOwnedCalculation(List ownedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedCase() { if (ownedCase == null) { ownedCase = new ArrayList<>(); @@ -939,10 +920,10 @@ public void setOwnedCase(List ownedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedConcern() { if (ownedConcern == null) { ownedConcern = new ArrayList<>(); @@ -965,8 +946,8 @@ public void setOwnedConcern(Collection ownedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ViewpointDefinition") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ViewpointDefinition") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -986,10 +967,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConnection() { if (ownedConnection == null) { ownedConnection = new ArrayList<>(); @@ -1012,10 +993,10 @@ public void setOwnedConnection(List ownedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedConstraint() { if (ownedConstraint == null) { ownedConstraint = new ArrayList<>(); @@ -1038,10 +1019,10 @@ public void setOwnedConstraint(List ownedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEnumeration() { if (ownedEnumeration == null) { ownedEnumeration = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setOwnedEnumeration(List ownedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedFlow() { if (ownedFlow == null) { ownedFlow = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setOwnedFlow(Collection ownedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedInterface() { if (ownedInterface == null) { ownedInterface = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setOwnedInterface(List ownedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedItem() { if (ownedItem == null) { ownedItem = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setOwnedItem(List ownedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedOccurrence() { if (ownedOccurrence == null) { ownedOccurrence = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setOwnedOccurrence(List ownedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPart() { if (ownedPart == null) { ownedPart = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setOwnedPart(List ownedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedPort() { if (ownedPort == null) { ownedPort = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setOwnedPort(List ownedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedReference() { if (ownedReference == null) { ownedReference = new ArrayList<>(); @@ -1452,10 +1433,10 @@ public void setOwnedReference(List ownedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -1478,10 +1459,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRendering() { if (ownedRendering == null) { ownedRendering = new ArrayList<>(); @@ -1504,10 +1485,10 @@ public void setOwnedRendering(List ownedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRequirement() { if (ownedRequirement == null) { ownedRequirement = new ArrayList<>(); @@ -1530,10 +1511,10 @@ public void setOwnedRequirement(List ownedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -1556,10 +1537,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedState() { if (ownedState == null) { ownedState = new ArrayList<>(); @@ -1582,10 +1563,10 @@ public void setOwnedState(List ownedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubclassificationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedSubclassification", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubclassification() { if (ownedSubclassification == null) { ownedSubclassification = new ArrayList<>(); @@ -1608,10 +1589,10 @@ public void setOwnedSubclassification(Collection ownedSubclas @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedTransition() { if (ownedTransition == null) { ownedTransition = new ArrayList<>(); @@ -1634,10 +1615,10 @@ public void setOwnedTransition(Collection ownedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUsage() { if (ownedUsage == null) { ownedUsage = new ArrayList<>(); @@ -1660,10 +1641,10 @@ public void setOwnedUsage(List ownedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedUseCase() { if (ownedUseCase == null) { ownedUseCase = new ArrayList<>(); @@ -1686,10 +1667,10 @@ public void setOwnedUseCase(List ownedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedVerificationCase() { if (ownedVerificationCase == null) { ownedVerificationCase = new ArrayList<>(); @@ -1712,10 +1693,10 @@ public void setOwnedVerificationCase(List ownedVerificati @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedView() { if (ownedView == null) { ownedView = new ArrayList<>(); @@ -1738,10 +1719,10 @@ public void setOwnedView(List ownedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_ownedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedViewpoint() { if (ownedViewpoint == null) { ownedViewpoint = new ArrayList<>(); @@ -1764,8 +1745,8 @@ public void setOwnedViewpoint(List ownedViewpoint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ViewpointDefinition") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ViewpointDefinition") public Element getOwner() { return owner; } @@ -1779,19 +1760,19 @@ public void setOwner(Element owner) { // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ViewpointDefinition") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ViewpointDefinition") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -1804,8 +1785,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ViewpointDefinition") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ViewpointDefinition") public Namespace getOwningNamespace() { return owningNamespace; } @@ -1823,8 +1804,8 @@ 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 = "ViewpointDefinition") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ViewpointDefinition") public Relationship getOwningRelationship() { return owningRelationship; } @@ -1844,10 +1825,10 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -1908,10 +1889,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -1934,8 +1915,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "ViewpointDefinition") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "ViewpointDefinition") public Feature getResult() { return result; } @@ -1948,6 +1929,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ViewpointDefinition") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -1955,10 +1954,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -1981,10 +1980,10 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StepMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_step", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getStep() { if (step == null) { step = new ArrayList<>(); @@ -2007,8 +2006,8 @@ public void setStep(Collection step) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "ViewpointDefinition") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "ViewpointDefinition") public Usage getSubjectParameter() { return subjectParameter; } @@ -2031,7 +2030,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "ViewpointDefinition_text", - joinColumns = @JoinColumn(name = "ViewpointDefinitionId")) + joinColumns = @JoinColumn(name = "ViewpointDefinition_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2053,10 +2052,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2079,10 +2078,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2105,10 +2104,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2131,10 +2130,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -2157,10 +2156,10 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointDefinition_viewpointStakeholder", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getViewpointStakeholder() { if (viewpointStakeholder == null) { viewpointStakeholder = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/ViewpointUsageImpl.java b/app/org/omg/sysml/metamodel/impl/ViewpointUsageImpl.java index ddd5b4f6..03af4044 100644 --- a/app/org/omg/sysml/metamodel/impl/ViewpointUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/ViewpointUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class ViewpointUsageImpl extends SysMLTypeImpl implements ViewpointUsage @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_actorParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActorParameter() { if (actorParameter == null) { actorParameter = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActorParameter(List actorParameter) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "ViewpointUsage_aliasId", - joinColumns = @JoinColumn(name = "ViewpointUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "ViewpointUsage_aliasIds", + joinColumns = @JoinColumn(name = "ViewpointUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_assumedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getAssumedConstraint() { if (assumedConstraint == null) { assumedConstraint = new ArrayList<>(); @@ -151,10 +152,10 @@ public void setAssumedConstraint(List assumedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -177,10 +178,10 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -203,8 +204,8 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "constraintDefinitionId", table = "ViewpointUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "constraintDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "constraintDefinition_id", table = "ViewpointUsage") public Predicate getConstraintDefinition() { return constraintDefinition; } @@ -224,10 +225,10 @@ public void setConstraintDefinition(Predicate constraintDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -250,10 +251,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -276,10 +277,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -320,10 +321,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -359,6 +360,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "ViewpointUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -366,10 +383,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -392,8 +409,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "ViewpointUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "ViewpointUsage") public Type getEndOwningType() { return endOwningType; } @@ -413,10 +430,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -465,10 +482,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -491,10 +508,10 @@ public void setFeaturingType(List featuringType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_framedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFramedConcern() { if (framedConcern == null) { framedConcern = new ArrayList<>(); @@ -517,8 +534,8 @@ public void setFramedConcern(List framedConcern) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "functionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "functionId", table = "ViewpointUsage") + @Any(metaDef = "FunctionMetaDef", metaColumn = @javax.persistence.Column(name = "function_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "function_id", table = "ViewpointUsage") public Function getFunction() { return function; } @@ -531,40 +548,6 @@ public void setFunction(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 = "ViewpointUsage") - 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 = "ViewpointUsage") - 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; @@ -572,10 +555,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -598,8 +581,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "ViewpointUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "ViewpointUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -619,10 +602,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -645,10 +628,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -671,10 +654,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -945,10 +928,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -971,10 +954,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -997,8 +980,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "ViewpointUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "ViewpointUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -1011,14 +994,12 @@ public void setMultiplicity(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 = "ViewpointUsage") public String getName() { return name; @@ -1038,10 +1019,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -1064,10 +1045,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -1090,10 +1071,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1116,10 +1097,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1142,10 +1123,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1168,10 +1149,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1194,10 +1175,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1220,10 +1201,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1246,10 +1227,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1272,10 +1253,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1298,10 +1279,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1324,10 +1305,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1350,10 +1331,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1376,10 +1357,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1402,10 +1383,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1428,10 +1409,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1454,10 +1435,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1480,10 +1461,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1506,10 +1487,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1532,10 +1513,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1558,10 +1539,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1584,10 +1565,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1610,10 +1591,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1636,10 +1617,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1662,10 +1643,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1688,10 +1669,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1714,10 +1695,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1740,10 +1721,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1766,10 +1747,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1792,8 +1773,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "ViewpointUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "ViewpointUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1813,10 +1794,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1839,10 +1820,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1865,10 +1846,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1891,10 +1872,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1917,10 +1898,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1943,10 +1924,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1969,10 +1950,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1995,10 +1976,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -2021,10 +2002,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -2047,10 +2028,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -2071,10 +2052,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2097,10 +2078,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2123,10 +2104,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2149,10 +2130,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2175,10 +2156,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2201,8 +2182,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "ViewpointUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "ViewpointUsage") public Element getOwner() { return owner; } @@ -2222,8 +2203,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "ViewpointUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "ViewpointUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2241,8 +2222,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "ViewpointUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "ViewpointUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2256,19 +2237,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "ViewpointUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "ViewpointUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2281,8 +2262,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "ViewpointUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "ViewpointUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2300,8 +2281,8 @@ 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 = "ViewpointUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "ViewpointUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2321,8 +2302,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "ViewpointUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "ViewpointUsage") public Type getOwningType() { return owningType; } @@ -2342,8 +2323,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "ViewpointUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "ViewpointUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2363,10 +2344,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2407,8 +2388,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "ViewpointUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "ViewpointUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2428,8 +2409,8 @@ public void setPortioningFeature(PortioningFeature portioningFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicateType"), fetch = FetchType.LAZY) - @JoinColumn(name = "predicateId", table = "ViewpointUsage") + @Any(metaDef = "PredicateMetaDef", metaColumn = @javax.persistence.Column(name = "predicate_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "predicate_id", table = "ViewpointUsage") public Predicate getPredicate() { return predicate; } @@ -2487,10 +2468,10 @@ public void setReqId(String reqId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_requiredConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getRequiredConstraint() { if (requiredConstraint == null) { requiredConstraint = new ArrayList<>(); @@ -2513,8 +2494,8 @@ public void setRequiredConstraint(List requiredConstraint) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "requirementDefinitionId", table = "ViewpointUsage") + @Any(metaDef = "RequirementDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "requirementDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "requirementDefinition_id", table = "ViewpointUsage") public RequirementDefinition getRequirementDefinition() { return requirementDefinition; } @@ -2534,8 +2515,8 @@ public void setRequirementDefinition(RequirementDefinition requirementDefinition @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "resultType"), fetch = FetchType.LAZY) - @JoinColumn(name = "resultId", table = "ViewpointUsage") + @Any(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "result_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "result_id", table = "ViewpointUsage") public Feature getResult() { return result; } @@ -2548,6 +2529,24 @@ public void setResult(Feature result) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "ViewpointUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("stakeholderParameter") private List stakeholderParameter; @@ -2555,10 +2554,10 @@ public void setResult(Feature result) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_stakeholderParameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getStakeholderParameter() { if (stakeholderParameter == null) { stakeholderParameter = new ArrayList<>(); @@ -2581,8 +2580,8 @@ public void setStakeholderParameter(List stakeholderParameter) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameterType"), fetch = FetchType.LAZY) - @JoinColumn(name = "subjectParameterId", table = "ViewpointUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "subjectParameter_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "subjectParameter_id", table = "ViewpointUsage") public Usage getSubjectParameter() { return subjectParameter; } @@ -2605,7 +2604,7 @@ public void setSubjectParameter(Usage subjectParameter) { // @javax.persistence.Transient @ElementCollection(targetClass = String.class) @CollectionTable(name = "ViewpointUsage_text", - joinColumns = @JoinColumn(name = "ViewpointUsageId")) + joinColumns = @JoinColumn(name = "ViewpointUsage_id")) public Collection getText() { if (text == null) { text = new ArrayList<>(); @@ -2627,10 +2626,10 @@ public void setText(Collection text) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2653,10 +2652,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2679,10 +2678,10 @@ public void setType(List type) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2705,10 +2704,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2731,10 +2730,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -2757,8 +2756,8 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ViewpointDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "viewpointDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "viewpointDefinitionId", table = "ViewpointUsage") + @Any(metaDef = "ViewpointDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "viewpointDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "viewpointDefinition_id", table = "ViewpointUsage") public ViewpointDefinition getViewpointDefinition() { return viewpointDefinition; } @@ -2778,10 +2777,10 @@ public void setViewpointDefinition(ViewpointDefinition viewpointDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "ViewpointUsage_viewpointStakeholder", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getViewpointStakeholder() { if (viewpointStakeholder == null) { viewpointStakeholder = new ArrayList<>(); diff --git a/app/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl.java b/app/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl.java index a3167f2f..87e3e2c7 100644 --- a/app/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl.java +++ b/app/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl.java @@ -1,7 +1,8 @@ /* * SysML v2 REST/HTTP Pilot Implementation - * Copyright (C) 2020 InterCAX LLC - * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2020 InterCAX LLC + * Copyright (C) 2020 California Institute of Technology ("Caltech") + * Copyright (C) 2021-2022 Twingineer LLC * * 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 @@ -76,10 +77,10 @@ public class WhileLoopActionUsageImpl extends SysMLTypeImpl implements WhileLoop @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_actionDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getActionDefinition() { if (actionDefinition == null) { actionDefinition = new ArrayList<>(); @@ -95,25 +96,25 @@ public void setActionDefinition(List actionDefinition) { - // @info.archinnov.achilles.annotations.Column("aliasId") - private List aliasId; + // @info.archinnov.achilles.annotations.Column("aliasIds") + private List aliasIds; @JsonGetter @Lob @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") @ElementCollection(targetClass = String.class) - @CollectionTable(name = "WhileLoopActionUsage_aliasId", - joinColumns = @JoinColumn(name = "WhileLoopActionUsageId")) - public List getAliasId() { - if (aliasId == null) { - aliasId = new ArrayList<>(); + @CollectionTable(name = "WhileLoopActionUsage_aliasIds", + joinColumns = @JoinColumn(name = "WhileLoopActionUsage_id")) + public List getAliasIds() { + if (aliasIds == null) { + aliasIds = new ArrayList<>(); } - return aliasId; + return aliasIds; } @JsonSetter - public void setAliasId(List aliasId) { - this.aliasId = aliasId; + public void setAliasIds(List aliasIds) { + this.aliasIds = aliasIds; } @@ -125,10 +126,10 @@ public void setAliasId(List aliasId) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "BehaviorMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_behavior", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getBehavior() { if (behavior == null) { behavior = new ArrayList<>(); @@ -151,8 +152,8 @@ public void setBehavior(List behavior) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "bodyActionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "bodyActionId", table = "WhileLoopActionUsage") + @Any(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "bodyAction_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "bodyAction_id", table = "WhileLoopActionUsage") public ActionUsage getBodyAction() { return bodyAction; } @@ -172,10 +173,10 @@ public void setBodyAction(ActionUsage bodyAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_chainingFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getChainingFeature() { if (chainingFeature == null) { chainingFeature = new ArrayList<>(); @@ -198,10 +199,10 @@ public void setChainingFeature(List chainingFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassifierMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_definition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDefinition() { if (definition == null) { definition = new ArrayList<>(); @@ -224,10 +225,10 @@ public void setDefinition(List definition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_directedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedFeature() { if (directedFeature == null) { directedFeature = new ArrayList<>(); @@ -250,10 +251,10 @@ public void setDirectedFeature(List directedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_directedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDirectedUsage() { if (directedUsage == null) { directedUsage = new ArrayList<>(); @@ -294,10 +295,10 @@ public void setDirection(FeatureDirectionKind direction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DocumentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_documentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getDocumentation() { if (documentation == null) { documentation = new ArrayList<>(); @@ -333,6 +334,22 @@ public void setEffectiveName(String effectiveName) { + // @info.archinnov.achilles.annotations.Column("elementId") + private java.util.UUID elementId; + + @JsonGetter + @javax.persistence.Column(name = "elementId", table = "WhileLoopActionUsage") + public java.util.UUID getElementId() { + return elementId; + } + + @JsonSetter + public void setElementId(java.util.UUID elementId) { + this.elementId = elementId; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("endFeature") private List endFeature; @@ -340,10 +357,10 @@ public void setEffectiveName(String effectiveName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_endFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getEndFeature() { if (endFeature == null) { endFeature = new ArrayList<>(); @@ -366,8 +383,8 @@ public void setEndFeature(List endFeature) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "endOwningTypeId", table = "WhileLoopActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "endOwningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "endOwningType_id", table = "WhileLoopActionUsage") public Type getEndOwningType() { return endOwningType; } @@ -387,10 +404,10 @@ public void setEndOwningType(Type endOwningType) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_feature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeature() { if (feature == null) { feature = new ArrayList<>(); @@ -413,10 +430,10 @@ public void setFeature(List feature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_featureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeatureMembership() { if (featureMembership == null) { featureMembership = new ArrayList<>(); @@ -439,10 +456,10 @@ public void setFeatureMembership(List featureMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_featuringType", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getFeaturingType() { if (featuringType == null) { featuringType = new ArrayList<>(); @@ -458,40 +475,6 @@ public void setFeaturingType(List featuringType) { - // @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 = "WhileLoopActionUsage") - 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 = "WhileLoopActionUsage") - 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; @@ -499,10 +482,10 @@ public void setIdentifier(java.util.UUID identifier) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_importedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getImportedMembership() { if (importedMembership == null) { importedMembership = new ArrayList<>(); @@ -525,8 +508,8 @@ public void setImportedMembership(List importedMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "individualDefinitionId", table = "WhileLoopActionUsage") + @Any(metaDef = "OccurrenceDefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "individualDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "individualDefinition_id", table = "WhileLoopActionUsage") public OccurrenceDefinition getIndividualDefinition() { return individualDefinition; } @@ -546,10 +529,10 @@ public void setIndividualDefinition(OccurrenceDefinition individualDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_inheritedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedFeature() { if (inheritedFeature == null) { inheritedFeature = new ArrayList<>(); @@ -572,10 +555,10 @@ public void setInheritedFeature(List inheritedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_inheritedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInheritedMembership() { if (inheritedMembership == null) { inheritedMembership = new ArrayList<>(); @@ -598,10 +581,10 @@ public void setInheritedMembership(List inheritedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_input", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getInput() { if (input == null) { input = new ArrayList<>(); @@ -854,10 +837,10 @@ public void setIsVariation(Boolean isVariation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_member", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMember() { if (member == null) { member = new ArrayList<>(); @@ -880,10 +863,10 @@ public void setMember(List member) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_membership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getMembership() { if (membership == null) { membership = new ArrayList<>(); @@ -906,8 +889,8 @@ public void setMembership(List membership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicityType"), fetch = FetchType.LAZY) - @JoinColumn(name = "multiplicityId", table = "WhileLoopActionUsage") + @Any(metaDef = "MultiplicityMetaDef", metaColumn = @javax.persistence.Column(name = "multiplicity_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "multiplicity_id", table = "WhileLoopActionUsage") public Multiplicity getMultiplicity() { return multiplicity; } @@ -920,14 +903,12 @@ public void setMultiplicity(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 = "WhileLoopActionUsage") public String getName() { return name; @@ -947,10 +928,10 @@ public void setName(String name) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ActionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedAction", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAction() { if (nestedAction == null) { nestedAction = new ArrayList<>(); @@ -973,10 +954,10 @@ public void setNestedAction(List nestedAction) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AllocationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedAllocation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAllocation() { if (nestedAllocation == null) { nestedAllocation = new ArrayList<>(); @@ -999,10 +980,10 @@ public void setNestedAllocation(List nestedAllocation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnalysisCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedAnalysisCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAnalysisCase() { if (nestedAnalysisCase == null) { nestedAnalysisCase = new ArrayList<>(); @@ -1025,10 +1006,10 @@ public void setNestedAnalysisCase(List nestedAnalysisCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AttributeUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedAttribute", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedAttribute() { if (nestedAttribute == null) { nestedAttribute = new ArrayList<>(); @@ -1051,10 +1032,10 @@ public void setNestedAttribute(List nestedAttribute) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CalculationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedCalculation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCalculation() { if (nestedCalculation == null) { nestedCalculation = new ArrayList<>(); @@ -1077,10 +1058,10 @@ public void setNestedCalculation(List nestedCalculation) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "CaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedCase() { if (nestedCase == null) { nestedCase = new ArrayList<>(); @@ -1103,10 +1084,10 @@ public void setNestedCase(List nestedCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConcernUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedConcern", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedConcern() { if (nestedConcern == null) { nestedConcern = new ArrayList<>(); @@ -1129,10 +1110,10 @@ public void setNestedConcern(Collection nestedConcern) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConnectorAsUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedConnection", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConnection() { if (nestedConnection == null) { nestedConnection = new ArrayList<>(); @@ -1155,10 +1136,10 @@ public void setNestedConnection(List nestedConnection) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ConstraintUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedConstraint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedConstraint() { if (nestedConstraint == null) { nestedConstraint = new ArrayList<>(); @@ -1181,10 +1162,10 @@ public void setNestedConstraint(List nestedConstraint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "EnumerationUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedEnumeration", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedEnumeration() { if (nestedEnumeration == null) { nestedEnumeration = new ArrayList<>(); @@ -1207,10 +1188,10 @@ public void setNestedEnumeration(List nestedEnumeration) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FlowConnectionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedFlow", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedFlow() { if (nestedFlow == null) { nestedFlow = new ArrayList<>(); @@ -1233,10 +1214,10 @@ public void setNestedFlow(Collection nestedFlow) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "InterfaceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedInterface", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedInterface() { if (nestedInterface == null) { nestedInterface = new ArrayList<>(); @@ -1259,10 +1240,10 @@ public void setNestedInterface(List nestedInterface) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ItemUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedItem", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedItem() { if (nestedItem == null) { nestedItem = new ArrayList<>(); @@ -1285,10 +1266,10 @@ public void setNestedItem(List nestedItem) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "OccurrenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedOccurrence", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedOccurrence() { if (nestedOccurrence == null) { nestedOccurrence = new ArrayList<>(); @@ -1311,10 +1292,10 @@ public void setNestedOccurrence(List nestedOccurrence) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PartUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedPart", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPart() { if (nestedPart == null) { nestedPart = new ArrayList<>(); @@ -1337,10 +1318,10 @@ public void setNestedPart(List nestedPart) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "PortUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedPort", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedPort() { if (nestedPort == null) { nestedPort = new ArrayList<>(); @@ -1363,10 +1344,10 @@ public void setNestedPort(List nestedPort) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ReferenceUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedReference", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedReference() { if (nestedReference == null) { nestedReference = new ArrayList<>(); @@ -1389,10 +1370,10 @@ public void setNestedReference(List nestedReference) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RenderingUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedRendering", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRendering() { if (nestedRendering == null) { nestedRendering = new ArrayList<>(); @@ -1415,10 +1396,10 @@ public void setNestedRendering(List nestedRendering) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RequirementUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedRequirement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedRequirement() { if (nestedRequirement == null) { nestedRequirement = new ArrayList<>(); @@ -1441,10 +1422,10 @@ public void setNestedRequirement(List nestedRequirement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "StateUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedState", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedState() { if (nestedState == null) { nestedState = new ArrayList<>(); @@ -1467,10 +1448,10 @@ public void setNestedState(List nestedState) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TransitionUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedTransition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getNestedTransition() { if (nestedTransition == null) { nestedTransition = new ArrayList<>(); @@ -1493,10 +1474,10 @@ public void setNestedTransition(Collection nestedTransition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedUsage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUsage() { if (nestedUsage == null) { nestedUsage = new ArrayList<>(); @@ -1519,10 +1500,10 @@ public void setNestedUsage(List nestedUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UseCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedUseCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedUseCase() { if (nestedUseCase == null) { nestedUseCase = new ArrayList<>(); @@ -1545,10 +1526,10 @@ public void setNestedUseCase(List nestedUseCase) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VerificationCaseUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedVerificationCase", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedVerificationCase() { if (nestedVerificationCase == null) { nestedVerificationCase = new ArrayList<>(); @@ -1571,10 +1552,10 @@ public void setNestedVerificationCase(List nestedVerifica @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedView", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedView() { if (nestedView == null) { nestedView = new ArrayList<>(); @@ -1597,10 +1578,10 @@ public void setNestedView(List nestedView) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ViewpointUsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_nestedViewpoint", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getNestedViewpoint() { if (nestedViewpoint == null) { nestedViewpoint = new ArrayList<>(); @@ -1623,10 +1604,10 @@ public void setNestedViewpoint(List nestedViewpoint) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ClassMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_occurrenceDefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOccurrenceDefinition() { if (occurrenceDefinition == null) { occurrenceDefinition = new ArrayList<>(); @@ -1649,10 +1630,10 @@ public void setOccurrenceDefinition(List occurrenceDefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_output", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOutput() { if (output == null) { output = new ArrayList<>(); @@ -1675,10 +1656,10 @@ public void setOutput(List output) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "AnnotationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedAnnotation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedAnnotation() { if (ownedAnnotation == null) { ownedAnnotation = new ArrayList<>(); @@ -1701,8 +1682,8 @@ public void setOwnedAnnotation(List ownedAnnotation) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugatorType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownedConjugatorId", table = "WhileLoopActionUsage") + @Any(metaDef = "ConjugationMetaDef", metaColumn = @javax.persistence.Column(name = "ownedConjugator_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "ownedConjugator_id", table = "WhileLoopActionUsage") public Conjugation getOwnedConjugator() { return ownedConjugator; } @@ -1722,10 +1703,10 @@ public void setOwnedConjugator(Conjugation ownedConjugator) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "DisjoiningMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedDisjoining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedDisjoining() { if (ownedDisjoining == null) { ownedDisjoining = new ArrayList<>(); @@ -1748,10 +1729,10 @@ public void setOwnedDisjoining(Collection ownedDisjoining) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedElement", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedElement() { if (ownedElement == null) { ownedElement = new ArrayList<>(); @@ -1774,10 +1755,10 @@ public void setOwnedElement(List ownedElement) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedEndFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedEndFeature() { if (ownedEndFeature == null) { ownedEndFeature = new ArrayList<>(); @@ -1800,10 +1781,10 @@ public void setOwnedEndFeature(List ownedEndFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedFeature", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeature() { if (ownedFeature == null) { ownedFeature = new ArrayList<>(); @@ -1826,10 +1807,10 @@ public void setOwnedFeature(List ownedFeature) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureChainingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedFeatureChaining", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureChaining() { if (ownedFeatureChaining == null) { ownedFeatureChaining = new ArrayList<>(); @@ -1852,10 +1833,10 @@ public void setOwnedFeatureChaining(List ownedFeatureChaining) @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedFeatureMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedFeatureMembership() { if (ownedFeatureMembership == null) { ownedFeatureMembership = new ArrayList<>(); @@ -1878,10 +1859,10 @@ public void setOwnedFeatureMembership(List ownedFeatureMember @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ImportMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedImport", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedImport() { if (ownedImport == null) { ownedImport = new ArrayList<>(); @@ -1904,10 +1885,10 @@ public void setOwnedImport(List ownedImport) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedMember", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMember() { if (ownedMember == null) { ownedMember = new ArrayList<>(); @@ -1930,10 +1911,10 @@ public void setOwnedMember(List ownedMember) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedMembership() { if (ownedMembership == null) { ownedMembership = new ArrayList<>(); @@ -1956,10 +1937,10 @@ public void setOwnedMembership(List ownedMembership) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RedefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedRedefinition", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedRedefinition() { if (ownedRedefinition == null) { ownedRedefinition = new ArrayList<>(); @@ -1980,10 +1961,10 @@ public void setOwnedRedefinition(Collection ownedRedefinition) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) - @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedRelationship", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedRelationship() { if (ownedRelationship == null) { ownedRelationship = new ArrayList<>(); @@ -2006,10 +1987,10 @@ public void setOwnedRelationship(List ownedRelationship) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SpecializationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedSpecialization", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedSpecialization() { if (ownedSpecialization == null) { ownedSpecialization = new ArrayList<>(); @@ -2032,10 +2013,10 @@ public void setOwnedSpecialization(List ownedSpecialization) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "SubsettingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedSubsetting", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getOwnedSubsetting() { if (ownedSubsetting == null) { ownedSubsetting = new ArrayList<>(); @@ -2058,10 +2039,10 @@ public void setOwnedSubsetting(Collection ownedSubsetting) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeFeaturingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedTypeFeaturing", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTypeFeaturing() { if (ownedTypeFeaturing == null) { ownedTypeFeaturing = new ArrayList<>(); @@ -2084,10 +2065,10 @@ public void setOwnedTypeFeaturing(List ownedTypeFeaturing) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureTypingMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_ownedTyping", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getOwnedTyping() { if (ownedTyping == null) { ownedTyping = new ArrayList<>(); @@ -2110,8 +2091,8 @@ public void setOwnedTyping(List ownedTyping) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "ownerType"), fetch = FetchType.LAZY) - @JoinColumn(name = "ownerId", table = "WhileLoopActionUsage") + @Any(metaDef = "ElementMetaDef", metaColumn = @javax.persistence.Column(name = "owner_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owner_id", table = "WhileLoopActionUsage") public Element getOwner() { return owner; } @@ -2131,8 +2112,8 @@ public void setOwner(Element owner) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinitionType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningDefinitionId", table = "WhileLoopActionUsage") + @Any(metaDef = "DefinitionMetaDef", metaColumn = @javax.persistence.Column(name = "owningDefinition_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningDefinition_id", table = "WhileLoopActionUsage") public Definition getOwningDefinition() { return owningDefinition; } @@ -2150,8 +2131,8 @@ public void setOwningDefinition(Definition owningDefinition) { @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningFeatureMembershipId", table = "WhileLoopActionUsage") + @Any(metaDef = "FeatureMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningFeatureMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningFeatureMembership_id", table = "WhileLoopActionUsage") public FeatureMembership getOwningFeatureMembership() { return owningFeatureMembership; } @@ -2165,19 +2146,19 @@ public void setOwningFeatureMembership(FeatureMembership owningFeatureMembership // @info.archinnov.achilles.annotations.Column("owningMembership") - private Membership owningMembership; + private OwningMembership owningMembership; @JsonGetter @JsonSerialize(using = DataSerializer.class) - @Any(metaDef = "MembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembershipType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningMembershipId", table = "WhileLoopActionUsage") - public Membership getOwningMembership() { + @Any(metaDef = "OwningMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "owningMembership_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningMembership_id", table = "WhileLoopActionUsage") + public OwningMembership getOwningMembership() { return owningMembership; } @JsonSetter - @JsonDeserialize(using = DataDeserializer.class, as = MembershipImpl.class) - public void setOwningMembership(Membership owningMembership) { + @JsonDeserialize(using = DataDeserializer.class, as = OwningMembershipImpl.class) + public void setOwningMembership(OwningMembership owningMembership) { this.owningMembership = owningMembership; } @@ -2190,8 +2171,8 @@ public void setOwningMembership(Membership owningMembership) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespaceType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningNamespaceId", table = "WhileLoopActionUsage") + @Any(metaDef = "NamespaceMetaDef", metaColumn = @javax.persistence.Column(name = "owningNamespace_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningNamespace_id", table = "WhileLoopActionUsage") public Namespace getOwningNamespace() { return owningNamespace; } @@ -2209,8 +2190,8 @@ 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 = "WhileLoopActionUsage") + @Any(metaDef = "RelationshipMetaDef", metaColumn = @javax.persistence.Column(name = "owningRelationship_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningRelationship_id", table = "WhileLoopActionUsage") public Relationship getOwningRelationship() { return owningRelationship; } @@ -2230,8 +2211,8 @@ public void setOwningRelationship(Relationship owningRelationship) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningTypeType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningTypeId", table = "WhileLoopActionUsage") + @Any(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "owningType_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningType_id", table = "WhileLoopActionUsage") public Type getOwningType() { return owningType; } @@ -2251,8 +2232,8 @@ public void setOwningType(Type owningType) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsageType"), fetch = FetchType.LAZY) - @JoinColumn(name = "owningUsageId", table = "WhileLoopActionUsage") + @Any(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "owningUsage_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "owningUsage_id", table = "WhileLoopActionUsage") public Usage getOwningUsage() { return owningUsage; } @@ -2272,10 +2253,10 @@ public void setOwningUsage(Usage owningUsage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "FeatureMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_parameter", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getParameter() { if (parameter == null) { parameter = new ArrayList<>(); @@ -2316,8 +2297,8 @@ public void setPortionKind(PortionKind portionKind) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeatureType"), fetch = FetchType.LAZY) - @JoinColumn(name = "portioningFeatureId", table = "WhileLoopActionUsage") + @Any(metaDef = "PortioningFeatureMetaDef", metaColumn = @javax.persistence.Column(name = "portioningFeature_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "portioningFeature_id", table = "WhileLoopActionUsage") public PortioningFeature getPortioningFeature() { return portioningFeature; } @@ -2350,6 +2331,24 @@ public void setQualifiedName(String qualifiedName) { + // @info.archinnov.achilles.annotations.Column("shortName") + private String shortName; + + @JsonGetter + @Lob + @org.hibernate.annotations.Type(type = "org.hibernate.type.TextType") + @javax.persistence.Column(name = "shortName", table = "WhileLoopActionUsage") + public String getShortName() { + return shortName; + } + + @JsonSetter + public void setShortName(String shortName) { + this.shortName = shortName; + } + + + // @info.archinnov.achilles.annotations.Transient // @info.archinnov.achilles.annotations.Column("textualRepresentation") private List textualRepresentation; @@ -2357,10 +2356,10 @@ public void setQualifiedName(String qualifiedName) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TextualRepresentationMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_textualRepresentation", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getTextualRepresentation() { if (textualRepresentation == null) { textualRepresentation = new ArrayList<>(); @@ -2383,10 +2382,10 @@ public void setTextualRepresentation(List textualRepresen @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "TypeMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_type", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getType() { if (type == null) { type = new ArrayList<>(); @@ -2409,8 +2408,8 @@ public void setType(List type) { @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "untilArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "untilArgumentId", table = "WhileLoopActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "untilArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "untilArgument_id", table = "WhileLoopActionUsage") public Expression getUntilArgument() { return untilArgument; } @@ -2430,10 +2429,10 @@ public void setUntilArgument(Expression untilArgument) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_usage", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public List getUsage() { if (usage == null) { usage = new ArrayList<>(); @@ -2456,10 +2455,10 @@ public void setUsage(List usage) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "UsageMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_variant", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariant() { if (variant == null) { variant = new ArrayList<>(); @@ -2482,10 +2481,10 @@ public void setVariant(Collection variant) { @JsonGetter @JsonSerialize(contentUsing = DataSerializer.class) // @javax.persistence.Transient - @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attributeType"), fetch = FetchType.LAZY) + @ManyToAny(metaDef = "VariantMembershipMetaDef", metaColumn = @javax.persistence.Column(name = "attribute_type"), fetch = FetchType.LAZY) @JoinTable(name = "WhileLoopActionUsage_variantMembership", - joinColumns = @JoinColumn(name = "classId"), - inverseJoinColumns = @JoinColumn(name = "attributeId")) + joinColumns = @JoinColumn(name = "class_id"), + inverseJoinColumns = @JoinColumn(name = "attribute_id")) public Collection getVariantMembership() { if (variantMembership == null) { variantMembership = new ArrayList<>(); @@ -2508,8 +2507,8 @@ public void setVariantMembership(Collection variantMembership @JsonGetter @JsonSerialize(using = DataSerializer.class) // @javax.persistence.Transient - @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "whileArgumentType"), fetch = FetchType.LAZY) - @JoinColumn(name = "whileArgumentId", table = "WhileLoopActionUsage") + @Any(metaDef = "ExpressionMetaDef", metaColumn = @javax.persistence.Column(name = "whileArgument_type"), fetch = FetchType.LAZY) + @JoinColumn(name = "whileArgument_id", table = "WhileLoopActionUsage") public Expression getWhileArgument() { return whileArgument; } diff --git a/app/org/omg/sysml/metamodel/impl/package-info.java b/app/org/omg/sysml/metamodel/impl/package-info.java index 43896728..254ce13a 100644 --- a/app/org/omg/sysml/metamodel/impl/package-info.java +++ b/app/org/omg/sysml/metamodel/impl/package-info.java @@ -127,6 +127,7 @@ @MetaValue(value = "OccurrenceDefinition", targetEntity = OccurrenceDefinitionImpl.class), @MetaValue(value = "OccurrenceUsage", targetEntity = OccurrenceUsageImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), + @MetaValue(value = "OwningMembership", targetEntity = OwningMembershipImpl.class), @MetaValue(value = "Package", targetEntity = PackageImpl.class), @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @@ -689,6 +690,7 @@ @MetaValue(value = "OccurrenceDefinition", targetEntity = OccurrenceDefinitionImpl.class), @MetaValue(value = "OccurrenceUsage", targetEntity = OccurrenceUsageImpl.class), @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), + @MetaValue(value = "OwningMembership", targetEntity = OwningMembershipImpl.class), @MetaValue(value = "Package", targetEntity = PackageImpl.class), @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PartDefinition", targetEntity = PartDefinitionImpl.class), @@ -1102,6 +1104,7 @@ @MetaValue(value = "FramedConcernMembership", targetEntity = FramedConcernMembershipImpl.class), @MetaValue(value = "Membership", targetEntity = MembershipImpl.class), @MetaValue(value = "ObjectiveMembership", targetEntity = ObjectiveMembershipImpl.class), + @MetaValue(value = "OwningMembership", targetEntity = OwningMembershipImpl.class), @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "RequirementConstraintMembership", targetEntity = RequirementConstraintMembershipImpl.class), @MetaValue(value = "RequirementVerificationMembership", targetEntity = RequirementVerificationMembershipImpl.class), @@ -1355,6 +1358,28 @@ @MetaValue(value = "OperatorExpression", targetEntity = OperatorExpressionImpl.class), @MetaValue(value = "SelectExpression", targetEntity = SelectExpressionImpl.class), }), + @AnyMetaDef(name = "OwningMembershipMetaDef", metaType = "string", idType = "java.util.UUID", + metaValues = { + @MetaValue(value = "ActorMembership", targetEntity = ActorMembershipImpl.class), + @MetaValue(value = "ElementFilterMembership", targetEntity = ElementFilterMembershipImpl.class), + @MetaValue(value = "EndFeatureMembership", targetEntity = EndFeatureMembershipImpl.class), + @MetaValue(value = "FeatureMembership", targetEntity = FeatureMembershipImpl.class), + @MetaValue(value = "FeatureValue", targetEntity = FeatureValueImpl.class), + @MetaValue(value = "FramedConcernMembership", targetEntity = FramedConcernMembershipImpl.class), + @MetaValue(value = "ObjectiveMembership", targetEntity = ObjectiveMembershipImpl.class), + @MetaValue(value = "OwningMembership", targetEntity = OwningMembershipImpl.class), + @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), + @MetaValue(value = "RequirementConstraintMembership", targetEntity = RequirementConstraintMembershipImpl.class), + @MetaValue(value = "RequirementVerificationMembership", targetEntity = RequirementVerificationMembershipImpl.class), + @MetaValue(value = "ResultExpressionMembership", targetEntity = ResultExpressionMembershipImpl.class), + @MetaValue(value = "ReturnParameterMembership", targetEntity = ReturnParameterMembershipImpl.class), + @MetaValue(value = "StakeholderMembership", targetEntity = StakeholderMembershipImpl.class), + @MetaValue(value = "StateSubactionMembership", targetEntity = StateSubactionMembershipImpl.class), + @MetaValue(value = "SubjectMembership", targetEntity = SubjectMembershipImpl.class), + @MetaValue(value = "TransitionFeatureMembership", targetEntity = TransitionFeatureMembershipImpl.class), + @MetaValue(value = "VariantMembership", targetEntity = VariantMembershipImpl.class), + @MetaValue(value = "ViewRenderingMembership", targetEntity = ViewRenderingMembershipImpl.class), + }), @AnyMetaDef(name = "PackageMetaDef", metaType = "string", idType = "java.util.UUID", metaValues = { @MetaValue(value = "Package", targetEntity = PackageImpl.class), @@ -1460,6 +1485,7 @@ @MetaValue(value = "ItemFlow", targetEntity = ItemFlowImpl.class), @MetaValue(value = "Membership", targetEntity = MembershipImpl.class), @MetaValue(value = "ObjectiveMembership", targetEntity = ObjectiveMembershipImpl.class), + @MetaValue(value = "OwningMembership", targetEntity = OwningMembershipImpl.class), @MetaValue(value = "ParameterMembership", targetEntity = ParameterMembershipImpl.class), @MetaValue(value = "PortConjugation", targetEntity = PortConjugationImpl.class), @MetaValue(value = "Redefinition", targetEntity = RedefinitionImpl.class), diff --git a/app/services/ElementService.java b/app/services/ElementService.java index 137a6d60..403e7f59 100644 --- a/app/services/ElementService.java +++ b/app/services/ElementService.java @@ -48,7 +48,7 @@ public ElementService(ElementDao elementDao, ProjectDao projectDao, CommitDao co } public Optional create(Element element) { - return element.getIdentifier() != null ? dao.update(element) : dao.persist(element); + return element.getElementId() != null ? dao.update(element) : dao.persist(element); } public Optional getElementByCommitIdElementId(UUID commitId, UUID elementId) { diff --git a/app/services/RelationshipService.java b/app/services/RelationshipService.java index b6994e25..9d05a771 100644 --- a/app/services/RelationshipService.java +++ b/app/services/RelationshipService.java @@ -54,7 +54,7 @@ public RelationshipService(RelationshipDao relationshipDao, ElementDao elementDa } public Optional create(Relationship relationship) { - return relationship.getIdentifier() != null ? dao.update(relationship) : dao.persist(relationship); + return relationship.getElementId() != null ? dao.update(relationship) : dao.persist(relationship); } public List getRelationshipsByProjectCommitRelatedElement(UUID projectId, UUID commitId, UUID relatedElementId, RelationshipDirection direction, @Nullable UUID after, @Nullable UUID before, int maxResults) { diff --git a/conf/META-INF/persistence.xml b/conf/META-INF/persistence.xml index 0a8ac819..3c82dc6f 100644 --- a/conf/META-INF/persistence.xml +++ b/conf/META-INF/persistence.xml @@ -128,6 +128,7 @@ org.omg.sysml.metamodel.impl.OccurrenceDefinitionImpl org.omg.sysml.metamodel.impl.OccurrenceUsageImpl org.omg.sysml.metamodel.impl.OperatorExpressionImpl + org.omg.sysml.metamodel.impl.OwningMembershipImpl org.omg.sysml.metamodel.impl.PackageImpl org.omg.sysml.metamodel.impl.ParameterMembershipImpl org.omg.sysml.metamodel.impl.PartDefinitionImpl diff --git a/generated/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl_.java index c9b3b961..8bed9340 100644 --- a/generated/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AcceptActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class AcceptActionUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ActionDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ActionDefinitionImpl_.java index b2fe9ca6..88f7f7bb 100644 --- a/generated/org/omg/sysml/metamodel/impl/ActionDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ActionDefinitionImpl_.java @@ -66,8 +66,8 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute action; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -86,6 +86,7 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -106,6 +107,7 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -113,8 +115,6 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -136,8 +136,8 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static final String ACTION = "action"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -156,6 +156,7 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -176,6 +177,7 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -183,8 +185,6 @@ public abstract class ActionDefinitionImpl_ extends org.omg.sysml.lifecycle.impl public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/ActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ActionUsageImpl_.java index 353b92c6..e18b00d8 100644 --- a/generated/org/omg/sysml/metamodel/impl/ActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class ActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ActorMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ActorMembershipImpl_.java index e21a6ba3..88ba73ff 100644 --- a/generated/org/omg/sysml/metamodel/impl/ActorMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ActorMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ActorMembershipImpl.class) public abstract class ActorMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl_.java index 4aa3f51f..e2223ebb 100644 --- a/generated/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AllocationDefinitionImpl_.java @@ -66,8 +66,8 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -87,6 +87,7 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -109,6 +110,7 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute importedMembership; public static volatile ListAttribute allocation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -119,9 +121,7 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute associationEnd; public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; public static volatile ListAttribute connectionEnd; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -142,8 +142,8 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -163,6 +163,7 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -185,6 +186,7 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String ALLOCATION = "allocation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -195,9 +197,7 @@ public abstract class AllocationDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String ASSOCIATION_END = "associationEnd"; public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - public static final String HUMAN_ID = "humanId"; public static final String CONNECTION_END = "connectionEnd"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/AllocationUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/AllocationUsageImpl_.java index a4d9fd0b..113c83bd 100644 --- a/generated/org/omg/sysml/metamodel/impl/AllocationUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AllocationUsageImpl_.java @@ -76,7 +76,6 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -87,6 +86,7 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedCalculation; public static volatile ListAttribute relatedElement; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -103,12 +103,12 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute relatedFeature; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; @@ -124,6 +124,7 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -162,7 +163,6 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String USAGE = "usage"; @@ -176,7 +176,6 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -187,6 +186,7 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_CALCULATION = "nestedCalculation"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -203,12 +203,12 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String RELATED_FEATURE = "relatedFeature"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; @@ -224,6 +224,7 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -262,7 +263,6 @@ public abstract class AllocationUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl_.java index 24be9229..8c89e4f5 100644 --- a/generated/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AnalysisCaseDefinitionImpl_.java @@ -68,8 +68,8 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static volatile ListAttribute action; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -89,6 +89,7 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute analysisAction; @@ -112,6 +113,7 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -119,8 +121,6 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -143,8 +143,8 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static final String ACTION = "action"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -164,6 +164,7 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String ANALYSIS_ACTION = "analysisAction"; @@ -187,6 +188,7 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -194,8 +196,6 @@ public abstract class AnalysisCaseDefinitionImpl_ extends org.omg.sysml.lifecycl public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl_.java index 407acd49..835c4075 100644 --- a/generated/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AnalysisCaseUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -103,6 +103,7 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -137,6 +138,7 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -146,9 +148,7 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -173,8 +173,8 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -196,6 +196,7 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -230,6 +231,7 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -239,9 +241,7 @@ public abstract class AnalysisCaseUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/AnnotatingElementImpl_.java b/generated/org/omg/sysml/metamodel/impl/AnnotatingElementImpl_.java index 665a7688..7dfcc4c6 100644 --- a/generated/org/omg/sysml/metamodel/impl/AnnotatingElementImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AnnotatingElementImpl_.java @@ -16,31 +16,31 @@ public abstract class AnnotatingElementImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute annotation; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute annotatedElement; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; public static final String ANNOTATION = "annotation"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String ANNOTATED_ELEMENT = "annotatedElement"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/AnnotationImpl_.java b/generated/org/omg/sysml/metamodel/impl/AnnotationImpl_.java index dc6bbb4c..9dfd55c7 100644 --- a/generated/org/omg/sysml/metamodel/impl/AnnotationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AnnotationImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(AnnotationImpl.class) public abstract class AnnotationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl_.java index ec1d42ca..e9b622c8 100644 --- a/generated/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AssertConstraintUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -135,6 +136,7 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -144,9 +146,7 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -172,8 +172,8 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -193,6 +193,7 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -226,6 +227,7 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -235,9 +237,7 @@ public abstract class AssertConstraintUsageImpl_ extends org.omg.sysml.lifecycle public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl_.java index 0de752fe..7408ade6 100644 --- a/generated/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AssignmentActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class AssignmentActionUsageImpl_ extends org.omg.sysml.lifecycle public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/AssociationImpl_.java b/generated/org/omg/sysml/metamodel/impl/AssociationImpl_.java index eea4f169..e8edd075 100644 --- a/generated/org/omg/sysml/metamodel/impl/AssociationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AssociationImpl_.java @@ -40,11 +40,12 @@ public abstract class AssociationImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -58,11 +59,10 @@ public abstract class AssociationImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile CollectionAttribute associationEnd; public static volatile ListAttribute target; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -82,11 +82,12 @@ public abstract class AssociationImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -100,11 +101,10 @@ public abstract class AssociationImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String ASSOCIATION_END = "associationEnd"; public static final String TARGET = "target"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/AssociationStructureImpl_.java b/generated/org/omg/sysml/metamodel/impl/AssociationStructureImpl_.java index 5ab7c7ae..1a1a8f6b 100644 --- a/generated/org/omg/sysml/metamodel/impl/AssociationStructureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AssociationStructureImpl_.java @@ -40,11 +40,12 @@ public abstract class AssociationStructureImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -58,11 +59,10 @@ public abstract class AssociationStructureImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute associationEnd; public static volatile ListAttribute target; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -82,11 +82,12 @@ public abstract class AssociationStructureImpl_ extends org.omg.sysml.lifecycle. public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -100,11 +101,10 @@ public abstract class AssociationStructureImpl_ extends org.omg.sysml.lifecycle. public static final String ASSOCIATION_END = "associationEnd"; public static final String TARGET = "target"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl_.java index bb5a990e..3232eab2 100644 --- a/generated/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AttributeDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -102,6 +103,7 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -109,8 +111,6 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -130,8 +130,8 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -150,6 +150,7 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -168,6 +169,7 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -175,8 +177,6 @@ public abstract class AttributeDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/AttributeUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/AttributeUsageImpl_.java index 91c4bddb..7a7aeb2f 100644 --- a/generated/org/omg/sysml/metamodel/impl/AttributeUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/AttributeUsageImpl_.java @@ -78,8 +78,8 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -99,6 +99,7 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -127,6 +128,7 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -135,9 +137,7 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute attributeDefinition; @@ -163,8 +163,8 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -184,6 +184,7 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -212,6 +213,7 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -220,9 +222,7 @@ public abstract class AttributeUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String ATTRIBUTE_DEFINITION = "attributeDefinition"; diff --git a/generated/org/omg/sysml/metamodel/impl/BehaviorImpl_.java b/generated/org/omg/sysml/metamodel/impl/BehaviorImpl_.java index 63887206..27b652d9 100644 --- a/generated/org/omg/sysml/metamodel/impl/BehaviorImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/BehaviorImpl_.java @@ -38,11 +38,12 @@ public abstract class BehaviorImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -53,11 +54,10 @@ public abstract class BehaviorImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute step; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -75,11 +75,12 @@ public abstract class BehaviorImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -90,11 +91,10 @@ public abstract class BehaviorImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String STEP = "step"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl_.java index 9e9a7320..a4f4701e 100644 --- a/generated/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/BindingConnectorAsUsageImpl_.java @@ -79,8 +79,8 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -133,6 +134,7 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -144,9 +146,7 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -172,8 +172,8 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -195,6 +195,7 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -226,6 +227,7 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -237,9 +239,7 @@ public abstract class BindingConnectorAsUsageImpl_ extends org.omg.sysml.lifecyc public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/BindingConnectorImpl_.java b/generated/org/omg/sysml/metamodel/impl/BindingConnectorImpl_.java index 2791d043..ec541e61 100644 --- a/generated/org/omg/sysml/metamodel/impl/BindingConnectorImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/BindingConnectorImpl_.java @@ -41,8 +41,8 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -57,6 +57,7 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -79,6 +80,7 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; @@ -86,8 +88,6 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute relatedFeature; public static volatile ListAttribute target; public static volatile SingularAttribute isDirected; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -101,8 +101,8 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -117,6 +117,7 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -139,6 +140,7 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String OWNED_IMPORT = "ownedImport"; @@ -146,8 +148,6 @@ public abstract class BindingConnectorImpl_ extends org.omg.sysml.lifecycle.impl public static final String RELATED_FEATURE = "relatedFeature"; public static final String TARGET = "target"; public static final String IS_DIRECTED = "isDirected"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/BooleanExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/BooleanExpressionImpl_.java index 3ca3932d..e13c8410 100644 --- a/generated/org/omg/sysml/metamodel/impl/BooleanExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/BooleanExpressionImpl_.java @@ -40,8 +40,8 @@ public abstract class BooleanExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class BooleanExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -76,12 +77,11 @@ public abstract class BooleanExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -94,8 +94,8 @@ public abstract class BooleanExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -108,6 +108,7 @@ public abstract class BooleanExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -130,12 +131,11 @@ public abstract class BooleanExpressionImpl_ extends org.omg.sysml.lifecycle.imp 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl_.java index 27b96e13..57ac0e68 100644 --- a/generated/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/CalculationDefinitionImpl_.java @@ -68,8 +68,8 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute action; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -88,6 +88,7 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -110,6 +111,7 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -117,8 +119,6 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -141,8 +141,8 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String ACTION = "action"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -161,6 +161,7 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -183,6 +184,7 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -190,8 +192,6 @@ public abstract class CalculationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/CalculationUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/CalculationUsageImpl_.java index 4d8a0203..1b8a65ba 100644 --- a/generated/org/omg/sysml/metamodel/impl/CalculationUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/CalculationUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -135,6 +136,7 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -144,9 +146,7 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -171,8 +171,8 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -193,6 +193,7 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -226,6 +227,7 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -235,9 +237,7 @@ public abstract class CalculationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/CaseDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/CaseDefinitionImpl_.java index 91a26f23..e2bdbfbe 100644 --- a/generated/org/omg/sysml/metamodel/impl/CaseDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/CaseDefinitionImpl_.java @@ -68,8 +68,8 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute action; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -89,6 +89,7 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -111,6 +112,7 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -118,8 +120,6 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -142,8 +142,8 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String ACTION = "action"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -163,6 +163,7 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -185,6 +186,7 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -192,8 +194,6 @@ public abstract class CaseDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/CaseUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/CaseUsageImpl_.java index bc4b8295..4ae5d8d6 100644 --- a/generated/org/omg/sysml/metamodel/impl/CaseUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/CaseUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -103,6 +103,7 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -136,6 +137,7 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -145,9 +147,7 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -172,8 +172,8 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -195,6 +195,7 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -228,6 +229,7 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -237,9 +239,7 @@ public abstract class CaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ClassImpl_.java b/generated/org/omg/sysml/metamodel/impl/ClassImpl_.java index aef1d47b..b2ac9455 100644 --- a/generated/org/omg/sysml/metamodel/impl/ClassImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ClassImpl_.java @@ -36,11 +36,12 @@ public abstract class ClassImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -51,10 +52,9 @@ public abstract class ClassImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -71,11 +71,12 @@ public abstract class ClassImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -86,10 +87,9 @@ public abstract class ClassImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/ClassifierImpl_.java b/generated/org/omg/sysml/metamodel/impl/ClassifierImpl_.java index 4d873ef2..530ec969 100644 --- a/generated/org/omg/sysml/metamodel/impl/ClassifierImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ClassifierImpl_.java @@ -36,11 +36,12 @@ public abstract class ClassifierImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -51,10 +52,9 @@ public abstract class ClassifierImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -71,11 +71,12 @@ public abstract class ClassifierImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -86,10 +87,9 @@ public abstract class ClassifierImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java index f4245022..1cd474d4 100644 --- a/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/CollectExpressionImpl_.java @@ -43,8 +43,8 @@ public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -57,6 +57,7 @@ public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -79,12 +80,11 @@ public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute operand; @@ -100,8 +100,8 @@ public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -114,6 +114,7 @@ public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -136,12 +137,11 @@ public abstract class CollectExpressionImpl_ extends org.omg.sysml.lifecycle.imp 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 ALIAS_IDS = "aliasIds"; 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 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/CommentImpl_.java b/generated/org/omg/sysml/metamodel/impl/CommentImpl_.java index 4bf043d5..1fc45d70 100644 --- a/generated/org/omg/sysml/metamodel/impl/CommentImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/CommentImpl_.java @@ -16,35 +16,35 @@ public abstract class CommentImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute annotation; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute annotatedElement; public static volatile SingularAttribute body; public static volatile SingularAttribute locale; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; public static final String ANNOTATION = "annotation"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String ANNOTATED_ELEMENT = "annotatedElement"; public static final String BODY = "body"; public static final String LOCALE = "locale"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl_.java index 06b85077..0c97649a 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConcernDefinitionImpl_.java @@ -69,8 +69,8 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute ownedItem; public static volatile CollectionAttribute text; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -93,6 +93,7 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -115,6 +116,7 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -122,8 +124,6 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -147,8 +147,8 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String OWNED_ITEM = "ownedItem"; public static final String TEXT = "text"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -171,6 +171,7 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -193,6 +194,7 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -200,8 +202,6 @@ public abstract class ConcernDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/ConcernUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConcernUsageImpl_.java index da426c9b..98690124 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConcernUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConcernUsageImpl_.java @@ -83,8 +83,8 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -108,6 +108,7 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -141,6 +142,7 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -150,9 +152,7 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -180,8 +180,8 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -205,6 +205,7 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -238,6 +239,7 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -247,9 +249,7 @@ public abstract class ConcernUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl_.java index 2bdc9add..7f00d41a 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConjugatedPortDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -103,6 +104,7 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -110,8 +112,6 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -131,8 +131,8 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -170,6 +171,7 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -177,8 +179,6 @@ public abstract class ConjugatedPortDefinitionImpl_ extends org.omg.sysml.lifecy public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl_.java index a28d9393..f41b4aa6 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConjugatedPortTypingImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(ConjugatedPortTypingImpl.class) public abstract class ConjugatedPortTypingImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ConjugationImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConjugationImpl_.java index 5d30d11d..8477a782 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConjugationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConjugationImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(ConjugationImpl.class) public abstract class ConjugationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl_.java index 5f2dd53a..41535e0d 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConnectionDefinitionImpl_.java @@ -66,8 +66,8 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -87,6 +87,7 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -108,6 +109,7 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -118,9 +120,7 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute associationEnd; public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; public static volatile ListAttribute connectionEnd; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -141,8 +141,8 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -162,6 +162,7 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -183,6 +184,7 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -193,9 +195,7 @@ public abstract class ConnectionDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String ASSOCIATION_END = "associationEnd"; public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - public static final String HUMAN_ID = "humanId"; public static final String CONNECTION_END = "connectionEnd"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/ConnectionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConnectionUsageImpl_.java index 0180d911..728cb15b 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConnectionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConnectionUsageImpl_.java @@ -75,7 +75,6 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -86,6 +85,7 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedCalculation; public static volatile ListAttribute relatedElement; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -102,12 +102,12 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute relatedFeature; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; @@ -122,6 +122,7 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -160,7 +161,6 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String USAGE = "usage"; @@ -174,7 +174,6 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -185,6 +184,7 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_CALCULATION = "nestedCalculation"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -201,12 +201,12 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String RELATED_FEATURE = "relatedFeature"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; @@ -221,6 +221,7 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -259,7 +260,6 @@ public abstract class ConnectionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl_.java index 485a32e7..41f320a1 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConnectorAsUsageImpl_.java @@ -79,8 +79,8 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -133,6 +134,7 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -144,9 +146,7 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -172,8 +172,8 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -195,6 +195,7 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -226,6 +227,7 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -237,9 +239,7 @@ public abstract class ConnectorAsUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ConnectorImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConnectorImpl_.java index 0d646ed4..2f075669 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConnectorImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConnectorImpl_.java @@ -41,8 +41,8 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -57,6 +57,7 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -79,6 +80,7 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; @@ -86,8 +88,6 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute relatedFeature; public static volatile ListAttribute target; public static volatile SingularAttribute isDirected; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -101,8 +101,8 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -117,6 +117,7 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -139,6 +140,7 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String OWNED_IMPORT = "ownedImport"; @@ -146,8 +148,6 @@ public abstract class ConnectorImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String RELATED_FEATURE = "relatedFeature"; public static final String TARGET = "target"; public static final String IS_DIRECTED = "isDirected"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl_.java index 9e9d7a76..7248b1af 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConstraintDefinitionImpl_.java @@ -66,8 +66,8 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -86,6 +86,7 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -108,6 +109,7 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -115,8 +117,6 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -137,8 +137,8 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -157,6 +157,7 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -179,6 +180,7 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -186,8 +188,6 @@ public abstract class ConstraintDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/ConstraintUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ConstraintUsageImpl_.java index 7f296429..c5fd1bf7 100644 --- a/generated/org/omg/sysml/metamodel/impl/ConstraintUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ConstraintUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -101,6 +101,7 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -191,6 +191,7 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class ConstraintUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ControlNodeImpl_.java b/generated/org/omg/sysml/metamodel/impl/ControlNodeImpl_.java index 641efc2f..71edc937 100644 --- a/generated/org/omg/sysml/metamodel/impl/ControlNodeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ControlNodeImpl_.java @@ -80,8 +80,8 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class ControlNodeImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/DataTypeImpl_.java b/generated/org/omg/sysml/metamodel/impl/DataTypeImpl_.java index f1ee65c7..c9a961e6 100644 --- a/generated/org/omg/sysml/metamodel/impl/DataTypeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/DataTypeImpl_.java @@ -36,11 +36,12 @@ public abstract class DataTypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -51,10 +52,9 @@ public abstract class DataTypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -71,11 +71,12 @@ public abstract class DataTypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -86,10 +87,9 @@ public abstract class DataTypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/DecisionNodeImpl_.java b/generated/org/omg/sysml/metamodel/impl/DecisionNodeImpl_.java index a6807708..1c6d1aa6 100644 --- a/generated/org/omg/sysml/metamodel/impl/DecisionNodeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/DecisionNodeImpl_.java @@ -80,8 +80,8 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class DecisionNodeImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/DefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/DefinitionImpl_.java index c6689dfd..12d60b90 100644 --- a/generated/org/omg/sysml/metamodel/impl/DefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/DefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -102,6 +103,7 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -109,8 +111,6 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -130,8 +130,8 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -150,6 +150,7 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -168,6 +169,7 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -175,8 +177,6 @@ public abstract class DefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/DependencyImpl_.java b/generated/org/omg/sysml/metamodel/impl/DependencyImpl_.java index 66dfcf84..e74b5bd8 100644 --- a/generated/org/omg/sysml/metamodel/impl/DependencyImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/DependencyImpl_.java @@ -15,40 +15,40 @@ @StaticMetamodel(DependencyImpl.class) public abstract class DependencyImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile ListAttribute supplier; public static volatile SingularAttribute name; public static volatile ListAttribute client; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String SUPPLIER = "supplier"; public static final String NAME = "name"; public static final String CLIENT = "client"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/DisjoiningImpl_.java b/generated/org/omg/sysml/metamodel/impl/DisjoiningImpl_.java index 11af0d5a..59587b19 100644 --- a/generated/org/omg/sysml/metamodel/impl/DisjoiningImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/DisjoiningImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(DisjoiningImpl.class) public abstract class DisjoiningImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/DocumentationImpl_.java b/generated/org/omg/sysml/metamodel/impl/DocumentationImpl_.java index 931b592b..8e8d6f5f 100644 --- a/generated/org/omg/sysml/metamodel/impl/DocumentationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/DocumentationImpl_.java @@ -16,35 +16,35 @@ public abstract class DocumentationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute annotation; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute annotatedElement; public static volatile SingularAttribute body; public static volatile SingularAttribute locale; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; public static final String ANNOTATION = "annotation"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String ANNOTATED_ELEMENT = "annotatedElement"; public static final String BODY = "body"; public static final String LOCALE = "locale"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl_.java index 19ffebbd..5bdc1849 100644 --- a/generated/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ElementFilterMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ElementFilterMembershipImpl.class) public abstract class ElementFilterMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ElementImpl_.java b/generated/org/omg/sysml/metamodel/impl/ElementImpl_.java index 67a5c809..a5afd6bd 100644 --- a/generated/org/omg/sysml/metamodel/impl/ElementImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ElementImpl_.java @@ -15,28 +15,28 @@ @StaticMetamodel(ElementImpl.class) public abstract class ElementImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl_.java index 701e6608..c7513e27 100644 --- a/generated/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/EndFeatureMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(EndFeatureMembershipImpl.class) public abstract class EndFeatureMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl_.java index cbc25db7..63a65e6f 100644 --- a/generated/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/EnumerationDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -102,6 +103,7 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -109,8 +111,6 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute enumeratedValue; public static volatile CollectionAttribute ownedConcern; @@ -131,8 +131,8 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -169,6 +170,7 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -176,8 +178,6 @@ public abstract class EnumerationDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 ENUMERATED_VALUE = "enumeratedValue"; public static final String OWNED_CONCERN = "ownedConcern"; diff --git a/generated/org/omg/sysml/metamodel/impl/EnumerationUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/EnumerationUsageImpl_.java index f01fb50a..7cbf87b8 100644 --- a/generated/org/omg/sysml/metamodel/impl/EnumerationUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/EnumerationUsageImpl_.java @@ -78,8 +78,8 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -99,6 +99,7 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -127,6 +128,7 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -135,9 +137,7 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute attributeDefinition; @@ -163,8 +163,8 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -184,6 +184,7 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -212,6 +213,7 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -220,9 +222,7 @@ public abstract class EnumerationUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String ATTRIBUTE_DEFINITION = "attributeDefinition"; diff --git a/generated/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl_.java index 4b04aad0..91933149 100644 --- a/generated/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/EventOccurrenceUsageImpl_.java @@ -79,8 +79,8 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -100,6 +100,7 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -130,6 +131,7 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -139,9 +141,7 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -166,8 +166,8 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -187,6 +187,7 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -217,6 +218,7 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -226,9 +228,7 @@ public abstract class EventOccurrenceUsageImpl_ extends org.omg.sysml.lifecycle. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl_.java index 357b20e0..4587f5cf 100644 --- a/generated/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ExhibitStateUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -103,6 +103,7 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -136,6 +137,7 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -145,9 +147,7 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -173,8 +173,8 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -195,6 +195,7 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -228,6 +229,7 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -237,9 +239,7 @@ public abstract class ExhibitStateUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ExposeImpl_.java b/generated/org/omg/sysml/metamodel/impl/ExposeImpl_.java index 8051c7a1..3f5f4913 100644 --- a/generated/org/omg/sysml/metamodel/impl/ExposeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ExposeImpl_.java @@ -16,11 +16,12 @@ @StaticMetamodel(ExposeImpl.class) public abstract class ExposeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute importedMemberName; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -29,18 +30,18 @@ public abstract class ExposeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile ListAttribute source; public static volatile ListAttribute target; public static volatile SingularAttribute isRecursive; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile SingularAttribute isImportAll; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String IMPORTED_MEMBER_NAME = "importedMemberName"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -49,11 +50,10 @@ public abstract class ExposeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String SOURCE = "source"; public static final String TARGET = "target"; public static final String IS_RECURSIVE = "isRecursive"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String IS_IMPORT_ALL = "isImportAll"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ExpressionImpl_.java index da034813..5c3609fc 100644 --- a/generated/org/omg/sysml/metamodel/impl/ExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ExpressionImpl_.java @@ -40,8 +40,8 @@ public abstract class ExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class ExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -76,12 +77,11 @@ public abstract class ExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -94,8 +94,8 @@ public abstract class ExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -108,6 +108,7 @@ public abstract class ExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -130,12 +131,11 @@ public abstract class ExpressionImpl_ extends org.omg.sysml.lifecycle.impl.DataI 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java index 6f09660c..2076298f 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureChainExpressionImpl_.java @@ -43,8 +43,8 @@ public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycl public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -57,6 +57,7 @@ public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycl public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -79,12 +80,11 @@ public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycl public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute operand; @@ -100,8 +100,8 @@ public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycl public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -114,6 +114,7 @@ public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycl public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -136,12 +137,11 @@ public abstract class FeatureChainExpressionImpl_ extends org.omg.sysml.lifecycl 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 ALIAS_IDS = "aliasIds"; 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 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/FeatureChainingImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureChainingImpl_.java index e3f10369..d9882922 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureChainingImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureChainingImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(FeatureChainingImpl.class) public abstract class FeatureChainingImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureImpl_.java index 59a22009..7345838d 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureImpl_.java @@ -39,8 +39,8 @@ public abstract class FeatureImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class FeatureImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class FeatureImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class FeatureImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class FeatureImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class FeatureImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureMembershipImpl_.java index b5de6d04..25955d46 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(FeatureMembershipImpl.class) public abstract class FeatureMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl_.java index b6f30c5e..6a7e6b80 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureReferenceExpressionImpl_.java @@ -40,8 +40,8 @@ public abstract class FeatureReferenceExpressionImpl_ extends org.omg.sysml.life public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class FeatureReferenceExpressionImpl_ extends org.omg.sysml.life public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -76,12 +77,11 @@ public abstract class FeatureReferenceExpressionImpl_ extends org.omg.sysml.life public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -94,8 +94,8 @@ public abstract class FeatureReferenceExpressionImpl_ extends org.omg.sysml.life public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -108,6 +108,7 @@ public abstract class FeatureReferenceExpressionImpl_ extends org.omg.sysml.life public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -130,12 +131,11 @@ public abstract class FeatureReferenceExpressionImpl_ extends org.omg.sysml.life 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureTypingImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureTypingImpl_.java index 3f277b80..a43bfdd6 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureTypingImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureTypingImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(FeatureTypingImpl.class) public abstract class FeatureTypingImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FeatureValueImpl_.java b/generated/org/omg/sysml/metamodel/impl/FeatureValueImpl_.java index 437d0823..3f0f642f 100644 --- a/generated/org/omg/sysml/metamodel/impl/FeatureValueImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FeatureValueImpl_.java @@ -16,47 +16,55 @@ @StaticMetamodel(FeatureValueImpl.class) public abstract class FeatureValueImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile SingularAttribute isInitial; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; public static volatile SingularAttribute isDefault; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String IS_INITIAL = "isInitial"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; public static final String IS_DEFAULT = "isDefault"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl_.java index b40db151..1a45fbd0 100644 --- a/generated/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FlowConnectionUsageImpl_.java @@ -80,7 +80,6 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -92,6 +91,7 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute targetInputFeature; public static volatile ListAttribute relatedElement; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -110,12 +110,12 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute relatedFeature; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; @@ -130,6 +130,7 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -172,7 +173,6 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String USAGE = "usage"; @@ -187,7 +187,6 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -199,6 +198,7 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String TARGET_INPUT_FEATURE = "targetInputFeature"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -217,12 +217,12 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String RELATED_FEATURE = "relatedFeature"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; @@ -237,6 +237,7 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -279,7 +280,6 @@ public abstract class FlowConnectionUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl_.java index 7a4073b9..36f2d0a5 100644 --- a/generated/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ForLoopActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class ForLoopActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ForkNodeImpl_.java b/generated/org/omg/sysml/metamodel/impl/ForkNodeImpl_.java index fac70367..70e5b148 100644 --- a/generated/org/omg/sysml/metamodel/impl/ForkNodeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ForkNodeImpl_.java @@ -80,8 +80,8 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class ForkNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl_.java index ba8796ef..9b580b59 100644 --- a/generated/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FramedConcernMembershipImpl_.java @@ -17,45 +17,53 @@ @StaticMetamodel(FramedConcernMembershipImpl.class) public abstract class FramedConcernMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile SingularAttribute kind; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String KIND = "kind"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/FunctionImpl_.java b/generated/org/omg/sysml/metamodel/impl/FunctionImpl_.java index 1dd4be84..0fb733f2 100644 --- a/generated/org/omg/sysml/metamodel/impl/FunctionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/FunctionImpl_.java @@ -39,13 +39,14 @@ public abstract class FunctionImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -56,11 +57,10 @@ public abstract class FunctionImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute step; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -78,13 +78,14 @@ public abstract class FunctionImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -95,11 +96,10 @@ public abstract class FunctionImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String STEP = "step"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/IfActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/IfActionUsageImpl_.java index c79ed709..b1d5e371 100644 --- a/generated/org/omg/sysml/metamodel/impl/IfActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/IfActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class IfActionUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ImportImpl_.java b/generated/org/omg/sysml/metamodel/impl/ImportImpl_.java index 63eb75f5..9dd6190a 100644 --- a/generated/org/omg/sysml/metamodel/impl/ImportImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ImportImpl_.java @@ -16,11 +16,12 @@ @StaticMetamodel(ImportImpl.class) public abstract class ImportImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute importedMemberName; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -29,18 +30,18 @@ public abstract class ImportImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile ListAttribute source; public static volatile ListAttribute target; public static volatile SingularAttribute isRecursive; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile SingularAttribute isImportAll; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String IMPORTED_MEMBER_NAME = "importedMemberName"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -49,11 +50,10 @@ public abstract class ImportImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String SOURCE = "source"; public static final String TARGET = "target"; public static final String IS_RECURSIVE = "isRecursive"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String IS_IMPORT_ALL = "isImportAll"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl_.java index 083a158d..714218cf 100644 --- a/generated/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/IncludeUseCaseUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -104,6 +104,7 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -137,6 +138,7 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -146,9 +148,7 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -174,8 +174,8 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -197,6 +197,7 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -230,6 +231,7 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -239,9 +241,7 @@ public abstract class IncludeUseCaseUsageImpl_ extends org.omg.sysml.lifecycle.i public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/InteractionImpl_.java b/generated/org/omg/sysml/metamodel/impl/InteractionImpl_.java index 8f22359a..d22993b4 100644 --- a/generated/org/omg/sysml/metamodel/impl/InteractionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/InteractionImpl_.java @@ -42,11 +42,12 @@ public abstract class InteractionImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -60,12 +61,11 @@ public abstract class InteractionImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile CollectionAttribute associationEnd; public static volatile ListAttribute target; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute step; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -86,11 +86,12 @@ public abstract class InteractionImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -104,12 +105,11 @@ public abstract class InteractionImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String ASSOCIATION_END = "associationEnd"; public static final String TARGET = "target"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String STEP = "step"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl_.java index 51334bf4..763261d0 100644 --- a/generated/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/InterfaceDefinitionImpl_.java @@ -66,8 +66,8 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -87,6 +87,7 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -108,6 +109,7 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -119,9 +121,7 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute target; public static volatile ListAttribute interfaceEnd; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; public static volatile ListAttribute connectionEnd; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -142,8 +142,8 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -163,6 +163,7 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -184,6 +185,7 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -195,9 +197,7 @@ public abstract class InterfaceDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String TARGET = "target"; public static final String INTERFACE_END = "interfaceEnd"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - public static final String HUMAN_ID = "humanId"; public static final String CONNECTION_END = "connectionEnd"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/InterfaceUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/InterfaceUsageImpl_.java index c67329b3..9c89ff01 100644 --- a/generated/org/omg/sysml/metamodel/impl/InterfaceUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/InterfaceUsageImpl_.java @@ -76,7 +76,6 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -87,6 +86,7 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute nestedCalculation; public static volatile ListAttribute relatedElement; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -103,12 +103,12 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute relatedFeature; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile CollectionAttribute interfaceDefinition; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; @@ -124,6 +124,7 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -162,7 +163,6 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String USAGE = "usage"; @@ -176,7 +176,6 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -187,6 +186,7 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NESTED_CALCULATION = "nestedCalculation"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -203,12 +203,12 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String RELATED_FEATURE = "relatedFeature"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String INTERFACE_DEFINITION = "interfaceDefinition"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; @@ -224,6 +224,7 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -262,7 +263,6 @@ public abstract class InterfaceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/InvariantImpl_.java b/generated/org/omg/sysml/metamodel/impl/InvariantImpl_.java index f6cab9f6..ae6a18f6 100644 --- a/generated/org/omg/sysml/metamodel/impl/InvariantImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/InvariantImpl_.java @@ -41,8 +41,8 @@ public abstract class InvariantImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -55,6 +55,7 @@ public abstract class InvariantImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -77,12 +78,11 @@ public abstract class InvariantImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -96,8 +96,8 @@ public abstract class InvariantImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -110,6 +110,7 @@ public abstract class InvariantImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -132,12 +133,11 @@ public abstract class InvariantImpl_ extends org.omg.sysml.lifecycle.impl.DataIm 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/InvocationExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/InvocationExpressionImpl_.java index 22d9e37f..2bde0902 100644 --- a/generated/org/omg/sysml/metamodel/impl/InvocationExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/InvocationExpressionImpl_.java @@ -42,8 +42,8 @@ public abstract class InvocationExpressionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -56,6 +56,7 @@ public abstract class InvocationExpressionImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -78,12 +79,11 @@ public abstract class InvocationExpressionImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String ARGUMENT = "argument"; @@ -97,8 +97,8 @@ public abstract class InvocationExpressionImpl_ extends org.omg.sysml.lifecycle. public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -111,6 +111,7 @@ public abstract class InvocationExpressionImpl_ extends org.omg.sysml.lifecycle. public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -133,12 +134,11 @@ public abstract class InvocationExpressionImpl_ extends org.omg.sysml.lifecycle. 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ItemDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ItemDefinitionImpl_.java index 0a34011b..e8aec6fe 100644 --- a/generated/org/omg/sysml/metamodel/impl/ItemDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ItemDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -103,6 +104,7 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -110,8 +112,6 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -131,8 +131,8 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -170,6 +171,7 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -177,8 +179,6 @@ public abstract class ItemDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/ItemFeatureImpl_.java b/generated/org/omg/sysml/metamodel/impl/ItemFeatureImpl_.java index 5f37ad0e..17c21a44 100644 --- a/generated/org/omg/sysml/metamodel/impl/ItemFeatureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ItemFeatureImpl_.java @@ -39,8 +39,8 @@ public abstract class ItemFeatureImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class ItemFeatureImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class ItemFeatureImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class ItemFeatureImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class ItemFeatureImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class ItemFeatureImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ItemFlowEndImpl_.java b/generated/org/omg/sysml/metamodel/impl/ItemFlowEndImpl_.java index 431b6778..2c6d138a 100644 --- a/generated/org/omg/sysml/metamodel/impl/ItemFlowEndImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ItemFlowEndImpl_.java @@ -39,8 +39,8 @@ public abstract class ItemFlowEndImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class ItemFlowEndImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class ItemFlowEndImpl_ extends org.omg.sysml.lifecycle.impl.Data public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class ItemFlowEndImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class ItemFlowEndImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class ItemFlowEndImpl_ extends org.omg.sysml.lifecycle.impl.Data public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl_.java b/generated/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl_.java index fec2aa49..30411188 100644 --- a/generated/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ItemFlowFeatureImpl_.java @@ -39,8 +39,8 @@ public abstract class ItemFlowFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class ItemFlowFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class ItemFlowFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class ItemFlowFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class ItemFlowFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class ItemFlowFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ItemFlowImpl_.java b/generated/org/omg/sysml/metamodel/impl/ItemFlowImpl_.java index fcb87b3a..11b7b036 100644 --- a/generated/org/omg/sysml/metamodel/impl/ItemFlowImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ItemFlowImpl_.java @@ -47,8 +47,8 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -65,6 +65,7 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile CollectionAttribute itemFlowEnd; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -92,6 +93,7 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile CollectionAttribute itemFlowFeature; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; @@ -99,8 +101,6 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute relatedFeature; public static volatile ListAttribute target; public static volatile SingularAttribute isDirected; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -115,8 +115,8 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -133,6 +133,7 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String ITEM_FLOW_END = "itemFlowEnd"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -160,6 +161,7 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String ITEM_FLOW_FEATURE = "itemFlowFeature"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String OWNED_IMPORT = "ownedImport"; @@ -167,8 +169,6 @@ public abstract class ItemFlowImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String RELATED_FEATURE = "relatedFeature"; public static final String TARGET = "target"; public static final String IS_DIRECTED = "isDirected"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ItemUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ItemUsageImpl_.java index ed81d6ac..293346fd 100644 --- a/generated/org/omg/sysml/metamodel/impl/ItemUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ItemUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -101,6 +101,7 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -131,6 +132,7 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -141,9 +143,7 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute itemDefinition; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -168,8 +168,8 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -189,6 +189,7 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -219,6 +220,7 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -229,9 +231,7 @@ public abstract class ItemUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String ITEM_DEFINITION = "itemDefinition"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/JoinNodeImpl_.java b/generated/org/omg/sysml/metamodel/impl/JoinNodeImpl_.java index 79e251cd..3ce84cea 100644 --- a/generated/org/omg/sysml/metamodel/impl/JoinNodeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/JoinNodeImpl_.java @@ -80,8 +80,8 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class JoinNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataImp public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/LifeClassImpl_.java b/generated/org/omg/sysml/metamodel/impl/LifeClassImpl_.java index 25b5ee7f..4febd21c 100644 --- a/generated/org/omg/sysml/metamodel/impl/LifeClassImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LifeClassImpl_.java @@ -36,11 +36,12 @@ public abstract class LifeClassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -51,10 +52,9 @@ public abstract class LifeClassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -71,11 +71,12 @@ public abstract class LifeClassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -86,10 +87,9 @@ public abstract class LifeClassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/LiteralBooleanImpl_.java b/generated/org/omg/sysml/metamodel/impl/LiteralBooleanImpl_.java index a0c7afad..b293ea1e 100644 --- a/generated/org/omg/sysml/metamodel/impl/LiteralBooleanImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LiteralBooleanImpl_.java @@ -40,8 +40,8 @@ public abstract class LiteralBooleanImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class LiteralBooleanImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -77,12 +78,11 @@ public abstract class LiteralBooleanImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -95,8 +95,8 @@ public abstract class LiteralBooleanImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -109,6 +109,7 @@ public abstract class LiteralBooleanImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -132,12 +133,11 @@ public abstract class LiteralBooleanImpl_ extends org.omg.sysml.lifecycle.impl.D 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/LiteralExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/LiteralExpressionImpl_.java index 9032fab7..0a719e42 100644 --- a/generated/org/omg/sysml/metamodel/impl/LiteralExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LiteralExpressionImpl_.java @@ -40,8 +40,8 @@ public abstract class LiteralExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class LiteralExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -76,12 +77,11 @@ public abstract class LiteralExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -94,8 +94,8 @@ public abstract class LiteralExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -108,6 +108,7 @@ public abstract class LiteralExpressionImpl_ extends org.omg.sysml.lifecycle.imp public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -130,12 +131,11 @@ public abstract class LiteralExpressionImpl_ extends org.omg.sysml.lifecycle.imp 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/LiteralInfinityImpl_.java b/generated/org/omg/sysml/metamodel/impl/LiteralInfinityImpl_.java index d4151f8c..af162877 100644 --- a/generated/org/omg/sysml/metamodel/impl/LiteralInfinityImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LiteralInfinityImpl_.java @@ -40,8 +40,8 @@ public abstract class LiteralInfinityImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class LiteralInfinityImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -76,12 +77,11 @@ public abstract class LiteralInfinityImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -94,8 +94,8 @@ public abstract class LiteralInfinityImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -108,6 +108,7 @@ public abstract class LiteralInfinityImpl_ extends org.omg.sysml.lifecycle.impl. public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -130,12 +131,11 @@ public abstract class LiteralInfinityImpl_ extends org.omg.sysml.lifecycle.impl. 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/LiteralIntegerImpl_.java b/generated/org/omg/sysml/metamodel/impl/LiteralIntegerImpl_.java index dc1c03ed..4d6893be 100644 --- a/generated/org/omg/sysml/metamodel/impl/LiteralIntegerImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LiteralIntegerImpl_.java @@ -40,8 +40,8 @@ public abstract class LiteralIntegerImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class LiteralIntegerImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -77,12 +78,11 @@ public abstract class LiteralIntegerImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -95,8 +95,8 @@ public abstract class LiteralIntegerImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -109,6 +109,7 @@ public abstract class LiteralIntegerImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -132,12 +133,11 @@ public abstract class LiteralIntegerImpl_ extends org.omg.sysml.lifecycle.impl.D 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/LiteralRationalImpl_.java b/generated/org/omg/sysml/metamodel/impl/LiteralRationalImpl_.java index fa13f867..6e692d8f 100644 --- a/generated/org/omg/sysml/metamodel/impl/LiteralRationalImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LiteralRationalImpl_.java @@ -40,8 +40,8 @@ public abstract class LiteralRationalImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class LiteralRationalImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -77,12 +78,11 @@ public abstract class LiteralRationalImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -95,8 +95,8 @@ public abstract class LiteralRationalImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -109,6 +109,7 @@ public abstract class LiteralRationalImpl_ extends org.omg.sysml.lifecycle.impl. public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -132,12 +133,11 @@ public abstract class LiteralRationalImpl_ extends org.omg.sysml.lifecycle.impl. 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/LiteralStringImpl_.java b/generated/org/omg/sysml/metamodel/impl/LiteralStringImpl_.java index 85255bbc..92cc071c 100644 --- a/generated/org/omg/sysml/metamodel/impl/LiteralStringImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LiteralStringImpl_.java @@ -40,8 +40,8 @@ public abstract class LiteralStringImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class LiteralStringImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -77,12 +78,11 @@ public abstract class LiteralStringImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -95,8 +95,8 @@ public abstract class LiteralStringImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -109,6 +109,7 @@ public abstract class LiteralStringImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -132,12 +133,11 @@ public abstract class LiteralStringImpl_ extends org.omg.sysml.lifecycle.impl.Da 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/LoopActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/LoopActionUsageImpl_.java index 3b4ad695..bcd1acf5 100644 --- a/generated/org/omg/sysml/metamodel/impl/LoopActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/LoopActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class LoopActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/MembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/MembershipImpl_.java index 35f0e7cd..f41aac51 100644 --- a/generated/org/omg/sysml/metamodel/impl/MembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MembershipImpl_.java @@ -16,42 +16,44 @@ @StaticMetamodel(MembershipImpl.class) public abstract class MembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/MergeNodeImpl_.java b/generated/org/omg/sysml/metamodel/impl/MergeNodeImpl_.java index db7c73f7..84dd8617 100644 --- a/generated/org/omg/sysml/metamodel/impl/MergeNodeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MergeNodeImpl_.java @@ -80,8 +80,8 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class MergeNodeImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/MetaclassImpl_.java b/generated/org/omg/sysml/metamodel/impl/MetaclassImpl_.java index 47efc19a..23352544 100644 --- a/generated/org/omg/sysml/metamodel/impl/MetaclassImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MetaclassImpl_.java @@ -36,11 +36,12 @@ public abstract class MetaclassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -51,10 +52,9 @@ public abstract class MetaclassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -71,11 +71,12 @@ public abstract class MetaclassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -86,10 +87,9 @@ public abstract class MetaclassImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl_.java index 2053c381..833f8c0a 100644 --- a/generated/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MetadataDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -103,6 +104,7 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -110,8 +112,6 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -131,8 +131,8 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -170,6 +171,7 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -177,8 +179,6 @@ public abstract class MetadataDefinitionImpl_ extends org.omg.sysml.lifecycle.im public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/MetadataFeatureImpl_.java b/generated/org/omg/sysml/metamodel/impl/MetadataFeatureImpl_.java index d40bdc5b..b75a9fe8 100644 --- a/generated/org/omg/sysml/metamodel/impl/MetadataFeatureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MetadataFeatureImpl_.java @@ -39,8 +39,8 @@ public abstract class MetadataFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class MetadataFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -73,13 +74,12 @@ public abstract class MetadataFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute annotation; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile ListAttribute annotatedElement; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -92,8 +92,8 @@ public abstract class MetadataFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -106,6 +106,7 @@ public abstract class MetadataFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -126,13 +127,12 @@ public abstract class MetadataFeatureImpl_ extends org.omg.sysml.lifecycle.impl. public static final String ANNOTATION = "annotation"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 ANNOTATED_ELEMENT = "annotatedElement"; public static final String IS_ABSTRACT = "isAbstract"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/MetadataUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/MetadataUsageImpl_.java index 734d1bb1..2bbc3325 100644 --- a/generated/org/omg/sysml/metamodel/impl/MetadataUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MetadataUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -101,6 +101,7 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -132,6 +133,7 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile ListAttribute annotation; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static volatile ListAttribute itemDefinition; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -191,6 +191,7 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -222,6 +223,7 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String ANNOTATION = "annotation"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class MetadataUsageImpl_ extends org.omg.sysml.lifecycle.impl.Da public static final String ITEM_DEFINITION = "itemDefinition"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/MultiplicityImpl_.java b/generated/org/omg/sysml/metamodel/impl/MultiplicityImpl_.java index 66d13d6c..38e61530 100644 --- a/generated/org/omg/sysml/metamodel/impl/MultiplicityImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MultiplicityImpl_.java @@ -39,8 +39,8 @@ public abstract class MultiplicityImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class MultiplicityImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class MultiplicityImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class MultiplicityImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class MultiplicityImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class MultiplicityImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl_.java b/generated/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl_.java index 419e839f..946b4a57 100644 --- a/generated/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/MultiplicityRangeImpl_.java @@ -40,8 +40,8 @@ public abstract class MultiplicityRangeImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class MultiplicityRangeImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -73,13 +74,12 @@ public abstract class MultiplicityRangeImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute bound; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -92,8 +92,8 @@ public abstract class MultiplicityRangeImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -106,6 +106,7 @@ public abstract class MultiplicityRangeImpl_ extends org.omg.sysml.lifecycle.imp public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -125,13 +126,12 @@ public abstract class MultiplicityRangeImpl_ extends org.omg.sysml.lifecycle.imp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String BOUND = "bound"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/NamespaceImpl_.java b/generated/org/omg/sysml/metamodel/impl/NamespaceImpl_.java index a27647e0..dbd54242 100644 --- a/generated/org/omg/sysml/metamodel/impl/NamespaceImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/NamespaceImpl_.java @@ -17,38 +17,38 @@ @StaticMetamodel(NamespaceImpl.class) public abstract class NamespaceImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute membership; public static volatile ListAttribute ownedImport; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute member; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String MEMBERSHIP = "membership"; public static final String OWNED_IMPORT = "ownedImport"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String MEMBER = "member"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/NullExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/NullExpressionImpl_.java index c3d9ca15..1c0de416 100644 --- a/generated/org/omg/sysml/metamodel/impl/NullExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/NullExpressionImpl_.java @@ -40,8 +40,8 @@ public abstract class NullExpressionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class NullExpressionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -76,12 +77,11 @@ public abstract class NullExpressionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -94,8 +94,8 @@ public abstract class NullExpressionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -108,6 +108,7 @@ public abstract class NullExpressionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -130,12 +131,11 @@ public abstract class NullExpressionImpl_ extends org.omg.sysml.lifecycle.impl.D 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl_.java index 6bf4c92c..ece43c07 100644 --- a/generated/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ObjectiveMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ObjectiveMembershipImpl.class) public abstract class ObjectiveMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl_.java index 4795f53b..d2c77333 100644 --- a/generated/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/OccurrenceDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -103,6 +104,7 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -110,8 +112,6 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -131,8 +131,8 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -170,6 +171,7 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -177,8 +179,6 @@ public abstract class OccurrenceDefinitionImpl_ extends org.omg.sysml.lifecycle. public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl_.java index c35a6388..0735d5b5 100644 --- a/generated/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/OccurrenceUsageImpl_.java @@ -79,8 +79,8 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -100,6 +100,7 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -130,6 +131,7 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -139,9 +141,7 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -166,8 +166,8 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -187,6 +187,7 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -217,6 +218,7 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -226,9 +228,7 @@ public abstract class OccurrenceUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/OperatorExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/OperatorExpressionImpl_.java index 680a07f1..c6f6aa95 100644 --- a/generated/org/omg/sysml/metamodel/impl/OperatorExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/OperatorExpressionImpl_.java @@ -43,8 +43,8 @@ public abstract class OperatorExpressionImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -57,6 +57,7 @@ public abstract class OperatorExpressionImpl_ extends org.omg.sysml.lifecycle.im public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -79,12 +80,11 @@ public abstract class OperatorExpressionImpl_ extends org.omg.sysml.lifecycle.im public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute operand; @@ -100,8 +100,8 @@ public abstract class OperatorExpressionImpl_ extends org.omg.sysml.lifecycle.im public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -114,6 +114,7 @@ public abstract class OperatorExpressionImpl_ extends org.omg.sysml.lifecycle.im public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -136,12 +137,11 @@ public abstract class OperatorExpressionImpl_ extends org.omg.sysml.lifecycle.im 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 ALIAS_IDS = "aliasIds"; 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 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/OwningMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/OwningMembershipImpl_.java new file mode 100644 index 00000000..c01cdfbb --- /dev/null +++ b/generated/org/omg/sysml/metamodel/impl/OwningMembershipImpl_.java @@ -0,0 +1,66 @@ +package org.omg.sysml.metamodel.impl; + +import java.util.UUID; +import javax.annotation.processing.Generated; +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.Documentation; +import org.omg.sysml.metamodel.Element; +import org.omg.sysml.metamodel.Relationship; +import org.omg.sysml.metamodel.TextualRepresentation; +import org.omg.sysml.metamodel.VisibilityKind; + +@Generated(value = "org.hibernate.jpamodelgen.JPAMetaModelEntityProcessor") +@StaticMetamodel(OwningMembershipImpl.class) +public abstract class OwningMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + + public static volatile SingularAttribute elementId; + public static volatile ListAttribute textualRepresentation; + public static volatile ListAttribute ownedAnnotation; + public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; + public static volatile SingularAttribute visibility; + public static volatile ListAttribute ownedRelationship; + public static volatile SingularAttribute qualifiedName; + public static volatile ListAttribute documentation; + public static volatile SingularAttribute ownedMemberElementId; + public static volatile SingularAttribute memberName; + public static volatile ListAttribute ownedRelatedElement; + public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; + public static volatile ListAttribute target; + public static volatile ListAttribute relatedElement; + public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; + public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + + public static final String ELEMENT_ID = "elementId"; + public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; + public static final String OWNED_ANNOTATION = "ownedAnnotation"; + public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; + public static final String VISIBILITY = "visibility"; + public static final String OWNED_RELATIONSHIP = "ownedRelationship"; + public static final String QUALIFIED_NAME = "qualifiedName"; + public static final String DOCUMENTATION = "documentation"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; + public static final String MEMBER_NAME = "memberName"; + public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; + public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; + public static final String TARGET = "target"; + public static final String RELATED_ELEMENT = "relatedElement"; + public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; + public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; + +} + diff --git a/generated/org/omg/sysml/metamodel/impl/PackageImpl_.java b/generated/org/omg/sysml/metamodel/impl/PackageImpl_.java index d24b89b5..eed26881 100644 --- a/generated/org/omg/sysml/metamodel/impl/PackageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PackageImpl_.java @@ -18,40 +18,40 @@ @StaticMetamodel(PackageImpl.class) public abstract class PackageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute membership; public static volatile ListAttribute ownedImport; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute filterCondition; public static volatile ListAttribute member; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String MEMBERSHIP = "membership"; public static final String OWNED_IMPORT = "ownedImport"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String FILTER_CONDITION = "filterCondition"; public static final String MEMBER = "member"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/ParameterMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ParameterMembershipImpl_.java index 5efffa28..fc916f62 100644 --- a/generated/org/omg/sysml/metamodel/impl/ParameterMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ParameterMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ParameterMembershipImpl.class) public abstract class ParameterMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/PartDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/PartDefinitionImpl_.java index 850543a4..fffcdc1f 100644 --- a/generated/org/omg/sysml/metamodel/impl/PartDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PartDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -103,6 +104,7 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -110,8 +112,6 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -131,8 +131,8 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -170,6 +171,7 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -177,8 +179,6 @@ public abstract class PartDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/PartUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/PartUsageImpl_.java index 29bb9de9..dc6e9230 100644 --- a/generated/org/omg/sysml/metamodel/impl/PartUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PartUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -133,6 +134,7 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute itemDefinition; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -191,6 +191,7 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -222,6 +223,7 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -232,9 +234,7 @@ public abstract class PartUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String ITEM_DEFINITION = "itemDefinition"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/PerformActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/PerformActionUsageImpl_.java index 9a55b10f..08da895d 100644 --- a/generated/org/omg/sysml/metamodel/impl/PerformActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PerformActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class PerformActionUsageImpl_ extends org.omg.sysml.lifecycle.im public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/PortConjugationImpl_.java b/generated/org/omg/sysml/metamodel/impl/PortConjugationImpl_.java index f822acbe..af557fa5 100644 --- a/generated/org/omg/sysml/metamodel/impl/PortConjugationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PortConjugationImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(PortConjugationImpl.class) public abstract class PortConjugationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/PortDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/PortDefinitionImpl_.java index 66af870f..47860a10 100644 --- a/generated/org/omg/sysml/metamodel/impl/PortDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PortDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -84,6 +84,7 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -103,6 +104,7 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -110,8 +112,6 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -131,8 +131,8 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -151,6 +151,7 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -170,6 +171,7 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -177,8 +179,6 @@ public abstract class PortDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/PortUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/PortUsageImpl_.java index a9bbfd0e..1ee6fff3 100644 --- a/generated/org/omg/sysml/metamodel/impl/PortUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PortUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -101,6 +101,7 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -132,6 +133,7 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -141,9 +143,7 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -168,8 +168,8 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -189,6 +189,7 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -220,6 +221,7 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -229,9 +231,7 @@ public abstract class PortUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/PortioningFeatureImpl_.java b/generated/org/omg/sysml/metamodel/impl/PortioningFeatureImpl_.java index c3476e62..d600495b 100644 --- a/generated/org/omg/sysml/metamodel/impl/PortioningFeatureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PortioningFeatureImpl_.java @@ -40,8 +40,8 @@ public abstract class PortioningFeatureImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class PortioningFeatureImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -73,13 +74,12 @@ public abstract class PortioningFeatureImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -92,8 +92,8 @@ public abstract class PortioningFeatureImpl_ extends org.omg.sysml.lifecycle.imp public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -106,6 +106,7 @@ public abstract class PortioningFeatureImpl_ extends org.omg.sysml.lifecycle.imp public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -125,13 +126,12 @@ public abstract class PortioningFeatureImpl_ extends org.omg.sysml.lifecycle.imp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/PredicateImpl_.java b/generated/org/omg/sysml/metamodel/impl/PredicateImpl_.java index 825044b3..8effaa43 100644 --- a/generated/org/omg/sysml/metamodel/impl/PredicateImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/PredicateImpl_.java @@ -39,13 +39,14 @@ public abstract class PredicateImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -56,11 +57,10 @@ public abstract class PredicateImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute step; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -78,13 +78,14 @@ public abstract class PredicateImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -95,11 +96,10 @@ public abstract class PredicateImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String STEP = "step"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/RedefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/RedefinitionImpl_.java index 5f61a34e..ad212a43 100644 --- a/generated/org/omg/sysml/metamodel/impl/RedefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RedefinitionImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(RedefinitionImpl.class) public abstract class RedefinitionImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ReferenceUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ReferenceUsageImpl_.java index 86d108d2..768dd1fc 100644 --- a/generated/org/omg/sysml/metamodel/impl/ReferenceUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ReferenceUsageImpl_.java @@ -77,8 +77,8 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -98,6 +98,7 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -126,6 +127,7 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -134,9 +136,7 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -161,8 +161,8 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -182,6 +182,7 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -210,6 +211,7 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -218,9 +220,7 @@ public abstract class ReferenceUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/RelationshipImpl_.java b/generated/org/omg/sysml/metamodel/impl/RelationshipImpl_.java index d163d90b..8664a27e 100644 --- a/generated/org/omg/sysml/metamodel/impl/RelationshipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RelationshipImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(RelationshipImpl.class) public abstract class RelationshipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl_.java index 535794ba..42982e3d 100644 --- a/generated/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RenderingDefinitionImpl_.java @@ -64,8 +64,8 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -85,6 +85,7 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -104,6 +105,7 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -111,8 +113,6 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -132,8 +132,8 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -153,6 +153,7 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -172,6 +173,7 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -179,8 +181,6 @@ public abstract class RenderingDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/RenderingUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/RenderingUsageImpl_.java index 0cb0c0c5..37255950 100644 --- a/generated/org/omg/sysml/metamodel/impl/RenderingUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RenderingUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -133,6 +134,7 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute itemDefinition; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -191,6 +191,7 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -222,6 +223,7 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -232,9 +234,7 @@ public abstract class RenderingUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String ITEM_DEFINITION = "itemDefinition"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl_.java index b1dc4e8c..e280e093 100644 --- a/generated/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RequirementConstraintMembershipImpl_.java @@ -17,45 +17,53 @@ @StaticMetamodel(RequirementConstraintMembershipImpl.class) public abstract class RequirementConstraintMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile SingularAttribute kind; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String KIND = "kind"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl_.java index 85c426bd..5dcb19a5 100644 --- a/generated/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RequirementDefinitionImpl_.java @@ -69,8 +69,8 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute ownedItem; public static volatile CollectionAttribute text; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -93,6 +93,7 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -115,6 +116,7 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -122,8 +124,6 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -147,8 +147,8 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String OWNED_ITEM = "ownedItem"; public static final String TEXT = "text"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -171,6 +171,7 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -193,6 +194,7 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -200,8 +202,6 @@ public abstract class RequirementDefinitionImpl_ extends org.omg.sysml.lifecycle public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/RequirementUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/RequirementUsageImpl_.java index b6033481..0dc5d57e 100644 --- a/generated/org/omg/sysml/metamodel/impl/RequirementUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RequirementUsageImpl_.java @@ -83,8 +83,8 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -108,6 +108,7 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -141,6 +142,7 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -150,9 +152,7 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -180,8 +180,8 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -205,6 +205,7 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -238,6 +239,7 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -247,9 +249,7 @@ public abstract class RequirementUsageImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl_.java index 674d7360..57652106 100644 --- a/generated/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/RequirementVerificationMembershipImpl_.java @@ -17,45 +17,53 @@ @StaticMetamodel(RequirementVerificationMembershipImpl.class) public abstract class RequirementVerificationMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile SingularAttribute kind; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String KIND = "kind"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl_.java index 9927c8e7..0f8ae696 100644 --- a/generated/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ResultExpressionMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ResultExpressionMembershipImpl.class) public abstract class ResultExpressionMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl_.java index 057e0966..54fe9016 100644 --- a/generated/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ReturnParameterMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ReturnParameterMembershipImpl.class) public abstract class ReturnParameterMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl_.java index 78274976..51384bde 100644 --- a/generated/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SatisfyRequirementUsageImpl_.java @@ -75,7 +75,6 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -88,6 +87,7 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static volatile ListAttribute nestedCalculation; public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -104,11 +104,11 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; @@ -123,6 +123,7 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -156,7 +157,6 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static volatile CollectionAttribute nestedConcern; public static volatile ListAttribute ownedImport; public static volatile CollectionAttribute variantMembership; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String REQUIRED_CONSTRAINT = "requiredConstraint"; @@ -173,7 +173,6 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -186,6 +185,7 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static final String NESTED_CALCULATION = "nestedCalculation"; public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -202,11 +202,11 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc 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 ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; @@ -221,6 +221,7 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -254,7 +255,6 @@ public abstract class SatisfyRequirementUsageImpl_ extends org.omg.sysml.lifecyc public static final String NESTED_CONCERN = "nestedConcern"; public static final String OWNED_IMPORT = "ownedImport"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java index 9da8f830..d553227c 100644 --- a/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SelectExpressionImpl_.java @@ -43,8 +43,8 @@ public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -57,6 +57,7 @@ public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -79,12 +80,11 @@ public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute operand; @@ -100,8 +100,8 @@ public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -114,6 +114,7 @@ public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -136,12 +137,11 @@ public abstract class SelectExpressionImpl_ extends org.omg.sysml.lifecycle.impl 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 ALIAS_IDS = "aliasIds"; 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 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/SendActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/SendActionUsageImpl_.java index 62306269..7dcd873f 100644 --- a/generated/org/omg/sysml/metamodel/impl/SendActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SendActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class SendActionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/SourceEndImpl_.java b/generated/org/omg/sysml/metamodel/impl/SourceEndImpl_.java index e5c570e3..aef37d7f 100644 --- a/generated/org/omg/sysml/metamodel/impl/SourceEndImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SourceEndImpl_.java @@ -39,8 +39,8 @@ public abstract class SourceEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class SourceEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class SourceEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class SourceEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class SourceEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class SourceEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SpecializationImpl_.java b/generated/org/omg/sysml/metamodel/impl/SpecializationImpl_.java index 52f55478..117ea413 100644 --- a/generated/org/omg/sysml/metamodel/impl/SpecializationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SpecializationImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(SpecializationImpl.class) public abstract class SpecializationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl_.java index a1e98cdc..9277173a 100644 --- a/generated/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/StakeholderMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(StakeholderMembershipImpl.class) public abstract class StakeholderMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/StateDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/StateDefinitionImpl_.java index c2ca7221..d142c40e 100644 --- a/generated/org/omg/sysml/metamodel/impl/StateDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/StateDefinitionImpl_.java @@ -67,8 +67,8 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute ownedItem; public static volatile ListAttribute state; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -87,6 +87,7 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -108,6 +109,7 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -115,8 +117,6 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -139,8 +139,8 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static final String OWNED_ITEM = "ownedItem"; public static final String STATE = "state"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -159,6 +159,7 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -180,6 +181,7 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -187,8 +189,6 @@ public abstract class StateDefinitionImpl_ extends org.omg.sysml.lifecycle.impl. public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl_.java index 687702b1..771fc86e 100644 --- a/generated/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/StateSubactionMembershipImpl_.java @@ -17,45 +17,53 @@ @StaticMetamodel(StateSubactionMembershipImpl.class) public abstract class StateSubactionMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile SingularAttribute kind; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String KIND = "kind"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/StateUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/StateUsageImpl_.java index 58d3eb40..0c457f19 100644 --- a/generated/org/omg/sysml/metamodel/impl/StateUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/StateUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -103,6 +103,7 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -136,6 +137,7 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -145,9 +147,7 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -173,8 +173,8 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -195,6 +195,7 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -228,6 +229,7 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -237,9 +239,7 @@ public abstract class StateUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/StepImpl_.java b/generated/org/omg/sysml/metamodel/impl/StepImpl_.java index e92061cc..b6d677b0 100644 --- a/generated/org/omg/sysml/metamodel/impl/StepImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/StepImpl_.java @@ -40,8 +40,8 @@ public abstract class StepImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -54,6 +54,7 @@ public abstract class StepImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -75,12 +76,11 @@ public abstract class StepImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -93,8 +93,8 @@ public abstract class StepImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -107,6 +107,7 @@ public abstract class StepImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -128,12 +129,11 @@ public abstract class StepImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/StructureImpl_.java b/generated/org/omg/sysml/metamodel/impl/StructureImpl_.java index 2a880ad5..bf69e94f 100644 --- a/generated/org/omg/sysml/metamodel/impl/StructureImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/StructureImpl_.java @@ -36,11 +36,12 @@ public abstract class StructureImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -51,10 +52,9 @@ public abstract class StructureImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -71,11 +71,12 @@ public abstract class StructureImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -86,10 +87,9 @@ public abstract class StructureImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/SubclassificationImpl_.java b/generated/org/omg/sysml/metamodel/impl/SubclassificationImpl_.java index a2f59d2c..7bc1ac36 100644 --- a/generated/org/omg/sysml/metamodel/impl/SubclassificationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SubclassificationImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(SubclassificationImpl.class) public abstract class SubclassificationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SubjectMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/SubjectMembershipImpl_.java index 2b3aeddf..9d6dfde8 100644 --- a/generated/org/omg/sysml/metamodel/impl/SubjectMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SubjectMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(SubjectMembershipImpl.class) public abstract class SubjectMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SubsettingImpl_.java b/generated/org/omg/sysml/metamodel/impl/SubsettingImpl_.java index b103f227..0baaf353 100644 --- a/generated/org/omg/sysml/metamodel/impl/SubsettingImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SubsettingImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(SubsettingImpl.class) public abstract class SubsettingImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl_.java index e0837ad7..f4867e3e 100644 --- a/generated/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SuccessionAsUsageImpl_.java @@ -82,8 +82,8 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -106,6 +106,7 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile CollectionAttribute effectStep; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -138,6 +139,7 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -149,9 +151,7 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -178,8 +178,8 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -202,6 +202,7 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String EFFECT_STEP = "effectStep"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -234,6 +235,7 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -245,9 +247,7 @@ public abstract class SuccessionAsUsageImpl_ extends org.omg.sysml.lifecycle.imp public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl_.java index 38a27ae8..5a83b92e 100644 --- a/generated/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SuccessionFlowConnectionUsageImpl_.java @@ -82,7 +82,6 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -94,6 +93,7 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static volatile ListAttribute targetInputFeature; public static volatile ListAttribute relatedElement; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -112,12 +112,12 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute relatedFeature; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; @@ -133,6 +133,7 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -177,7 +178,6 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static volatile ListAttribute target; public static volatile CollectionAttribute variantMembership; public static volatile SingularAttribute isDirected; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String USAGE = "usage"; @@ -192,7 +192,6 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -204,6 +203,7 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static final String TARGET_INPUT_FEATURE = "targetInputFeature"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -222,12 +222,12 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String RELATED_FEATURE = "relatedFeature"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; @@ -243,6 +243,7 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -287,7 +288,6 @@ public abstract class SuccessionFlowConnectionUsageImpl_ extends org.omg.sysml.l public static final String TARGET = "target"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String IS_DIRECTED = "isDirected"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SuccessionImpl_.java b/generated/org/omg/sysml/metamodel/impl/SuccessionImpl_.java index 7e9e4201..29eb8a3d 100644 --- a/generated/org/omg/sysml/metamodel/impl/SuccessionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SuccessionImpl_.java @@ -44,8 +44,8 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -61,6 +61,7 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile CollectionAttribute effectStep; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -84,6 +85,7 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; @@ -91,8 +93,6 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static volatile ListAttribute relatedFeature; public static volatile ListAttribute target; public static volatile SingularAttribute isDirected; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -107,8 +107,8 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -124,6 +124,7 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String EFFECT_STEP = "effectStep"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -147,6 +148,7 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String OWNED_IMPORT = "ownedImport"; @@ -154,8 +156,6 @@ public abstract class SuccessionImpl_ extends org.omg.sysml.lifecycle.impl.DataI public static final String RELATED_FEATURE = "relatedFeature"; public static final String TARGET = "target"; public static final String IS_DIRECTED = "isDirected"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl_.java b/generated/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl_.java index 318cac16..24befe8a 100644 --- a/generated/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/SuccessionItemFlowImpl_.java @@ -50,8 +50,8 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -69,6 +69,7 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static volatile CollectionAttribute effectStep; public static volatile SingularAttribute name; public static volatile CollectionAttribute connectorEnd; + public static volatile SingularAttribute shortName; public static volatile CollectionAttribute itemFlowEnd; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -97,6 +98,7 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static volatile CollectionAttribute itemFlowFeature; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; @@ -104,8 +106,6 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static volatile ListAttribute relatedFeature; public static volatile ListAttribute target; public static volatile SingularAttribute isDirected; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -121,8 +121,8 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -140,6 +140,7 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static final String EFFECT_STEP = "effectStep"; public static final String NAME = "name"; public static final String CONNECTOR_END = "connectorEnd"; + public static final String SHORT_NAME = "shortName"; public static final String ITEM_FLOW_END = "itemFlowEnd"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -168,6 +169,7 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static final String ITEM_FLOW_FEATURE = "itemFlowFeature"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String OWNED_IMPORT = "ownedImport"; @@ -175,8 +177,6 @@ public abstract class SuccessionItemFlowImpl_ extends org.omg.sysml.lifecycle.im public static final String RELATED_FEATURE = "relatedFeature"; public static final String TARGET = "target"; public static final String IS_DIRECTED = "isDirected"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/TargetEndImpl_.java b/generated/org/omg/sysml/metamodel/impl/TargetEndImpl_.java index 3b77a4f2..2aa617ef 100644 --- a/generated/org/omg/sysml/metamodel/impl/TargetEndImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TargetEndImpl_.java @@ -39,8 +39,8 @@ public abstract class TargetEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -53,6 +53,7 @@ public abstract class TargetEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -72,12 +73,11 @@ public abstract class TargetEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String CHAINING_FEATURE = "chainingFeature"; @@ -90,8 +90,8 @@ public abstract class TargetEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -104,6 +104,7 @@ public abstract class TargetEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -123,12 +124,11 @@ public abstract class TargetEndImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/TextualRepresentationImpl_.java b/generated/org/omg/sysml/metamodel/impl/TextualRepresentationImpl_.java index 8b7c05ca..3e4f495f 100644 --- a/generated/org/omg/sysml/metamodel/impl/TextualRepresentationImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TextualRepresentationImpl_.java @@ -16,35 +16,35 @@ public abstract class TextualRepresentationImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute annotation; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile SingularAttribute language; public static volatile ListAttribute annotatedElement; public static volatile SingularAttribute body; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; public static final String ANNOTATION = "annotation"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String LANGUAGE = "language"; public static final String ANNOTATED_ELEMENT = "annotatedElement"; public static final String BODY = "body"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl_.java index 279a5468..469ff459 100644 --- a/generated/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TransitionFeatureMembershipImpl_.java @@ -17,45 +17,53 @@ @StaticMetamodel(TransitionFeatureMembershipImpl.class) public abstract class TransitionFeatureMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile SingularAttribute kind; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String KIND = "kind"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/TransitionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/TransitionUsageImpl_.java index c7b21cfc..a1167bd5 100644 --- a/generated/org/omg/sysml/metamodel/impl/TransitionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TransitionUsageImpl_.java @@ -83,8 +83,8 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -105,6 +105,7 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -139,6 +140,7 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -148,9 +150,7 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -176,8 +176,8 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -198,6 +198,7 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -232,6 +233,7 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -241,9 +243,7 @@ public abstract class TransitionUsageImpl_ extends org.omg.sysml.lifecycle.impl. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl_.java b/generated/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl_.java index abd64e39..2822eebd 100644 --- a/generated/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TriggerInvocationExpressionImpl_.java @@ -43,8 +43,8 @@ public abstract class TriggerInvocationExpressionImpl_ extends org.omg.sysml.lif public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedFeature; @@ -58,6 +58,7 @@ public abstract class TriggerInvocationExpressionImpl_ extends org.omg.sysml.lif public static volatile ListAttribute input; public static volatile SingularAttribute isComposite; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile CollectionAttribute ownedDisjoining; @@ -80,12 +81,11 @@ public abstract class TriggerInvocationExpressionImpl_ extends org.omg.sysml.lif public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static final String ARGUMENT = "argument"; @@ -99,8 +99,8 @@ public abstract class TriggerInvocationExpressionImpl_ extends org.omg.sysml.lif public static final String IS_SUFFICIENT = "isSufficient"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - 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"; @@ -114,6 +114,7 @@ public abstract class TriggerInvocationExpressionImpl_ extends org.omg.sysml.lif public static final String INPUT = "input"; public static final String IS_COMPOSITE = "isComposite"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_DISJOINING = "ownedDisjoining"; @@ -136,12 +137,11 @@ public abstract class TriggerInvocationExpressionImpl_ extends org.omg.sysml.lif 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 ALIAS_IDS = "aliasIds"; 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 HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; } diff --git a/generated/org/omg/sysml/metamodel/impl/TypeFeaturingImpl_.java b/generated/org/omg/sysml/metamodel/impl/TypeFeaturingImpl_.java index 7d8844d2..b6360b5f 100644 --- a/generated/org/omg/sysml/metamodel/impl/TypeFeaturingImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TypeFeaturingImpl_.java @@ -15,36 +15,36 @@ @StaticMetamodel(TypeFeaturingImpl.class) public abstract class TypeFeaturingImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/TypeImpl_.java b/generated/org/omg/sysml/metamodel/impl/TypeImpl_.java index 44f0782b..36ee382b 100644 --- a/generated/org/omg/sysml/metamodel/impl/TypeImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/TypeImpl_.java @@ -34,11 +34,12 @@ public abstract class TypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute inheritedFeature; public static volatile SingularAttribute isSufficient; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedFeature; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; @@ -49,10 +50,9 @@ public abstract class TypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static volatile ListAttribute ownedImport; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute input; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile SingularAttribute name; public static volatile ListAttribute ownedSpecialization; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; @@ -68,11 +68,12 @@ public abstract class TypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static final String INHERITED_FEATURE = "inheritedFeature"; public static final String IS_SUFFICIENT = "isSufficient"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_FEATURE = "ownedFeature"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -83,10 +84,9 @@ public abstract class TypeImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { public static final String OWNED_IMPORT = "ownedImport"; public static final String IS_ABSTRACT = "isAbstract"; public static final String INPUT = "input"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String NAME = "name"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; diff --git a/generated/org/omg/sysml/metamodel/impl/UsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/UsageImpl_.java index 72cf8b4d..ca030187 100644 --- a/generated/org/omg/sysml/metamodel/impl/UsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/UsageImpl_.java @@ -77,8 +77,8 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -98,6 +98,7 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -126,6 +127,7 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -134,9 +136,7 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -161,8 +161,8 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -182,6 +182,7 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -210,6 +211,7 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -218,9 +220,7 @@ public abstract class UsageImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl_.java index 14e9fc30..cc1477b0 100644 --- a/generated/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/UseCaseDefinitionImpl_.java @@ -69,8 +69,8 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute action; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -90,6 +90,7 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -112,6 +113,7 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -119,8 +121,6 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -144,8 +144,8 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String ACTION = "action"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -165,6 +165,7 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -187,6 +188,7 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -194,8 +196,6 @@ public abstract class UseCaseDefinitionImpl_ extends org.omg.sysml.lifecycle.imp public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/UseCaseUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/UseCaseUsageImpl_.java index bbf04f28..ea6d3710 100644 --- a/generated/org/omg/sysml/metamodel/impl/UseCaseUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/UseCaseUsageImpl_.java @@ -81,8 +81,8 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -104,6 +104,7 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -137,6 +138,7 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -146,9 +148,7 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -174,8 +174,8 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -197,6 +197,7 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -230,6 +231,7 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -239,9 +241,7 @@ public abstract class UseCaseUsageImpl_ extends org.omg.sysml.lifecycle.impl.Dat public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/VariantMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/VariantMembershipImpl_.java index 3dc022a1..27593f1f 100644 --- a/generated/org/omg/sysml/metamodel/impl/VariantMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/VariantMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(VariantMembershipImpl.class) public abstract class VariantMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl_.java index 53dd646e..18d26c61 100644 --- a/generated/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/VerificationCaseDefinitionImpl_.java @@ -68,8 +68,8 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static volatile ListAttribute action; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -89,6 +89,7 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -112,6 +113,7 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -119,8 +121,6 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -143,8 +143,8 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static final String ACTION = "action"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -164,6 +164,7 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -187,6 +188,7 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -194,8 +196,6 @@ public abstract class VerificationCaseDefinitionImpl_ extends org.omg.sysml.life public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl_.java index b2c9f0ca..ac582849 100644 --- a/generated/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/VerificationCaseUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -103,6 +103,7 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -137,6 +138,7 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -146,9 +148,7 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -173,8 +173,8 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -196,6 +196,7 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -230,6 +231,7 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle 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 ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -239,9 +241,7 @@ public abstract class VerificationCaseUsageImpl_ extends org.omg.sysml.lifecycle public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ViewDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ViewDefinitionImpl_.java index a73527fb..5104798a 100644 --- a/generated/org/omg/sysml/metamodel/impl/ViewDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ViewDefinitionImpl_.java @@ -66,8 +66,8 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute variant; public static volatile ListAttribute ownedItem; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -86,6 +86,7 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -107,6 +108,7 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute effectiveName; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -114,8 +116,6 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile ListAttribute ownedAttribute; @@ -136,8 +136,8 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String VARIANT = "variant"; public static final String OWNED_ITEM = "ownedItem"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -156,6 +156,7 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -177,6 +178,7 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String EFFECTIVE_NAME = "effectiveName"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -184,8 +186,6 @@ public abstract class ViewDefinitionImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String OWNED_ATTRIBUTE = "ownedAttribute"; diff --git a/generated/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl_.java b/generated/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl_.java index a2f54b19..3f06a060 100644 --- a/generated/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ViewRenderingMembershipImpl_.java @@ -16,43 +16,51 @@ @StaticMetamodel(ViewRenderingMembershipImpl.class) public abstract class ViewRenderingMembershipImpl_ extends org.omg.sysml.lifecycle.impl.DataImpl_ { + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile SingularAttribute visibility; public static volatile ListAttribute ownedRelationship; public static volatile SingularAttribute qualifiedName; public static volatile ListAttribute documentation; - public static volatile SingularAttribute effectiveMemberName; + public static volatile SingularAttribute ownedMemberElementId; public static volatile SingularAttribute memberName; public static volatile ListAttribute ownedRelatedElement; public static volatile ListAttribute source; + public static volatile SingularAttribute memberElementId; public static volatile ListAttribute target; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute relatedElement; public static volatile SingularAttribute name; + public static volatile SingularAttribute memberShortName; + public static volatile SingularAttribute ownedMemberName; + public static volatile SingularAttribute shortName; public static volatile SingularAttribute effectiveName; + public static volatile SingularAttribute ownedMemberShortName; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String VISIBILITY = "visibility"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String QUALIFIED_NAME = "qualifiedName"; public static final String DOCUMENTATION = "documentation"; - public static final String EFFECTIVE_MEMBER_NAME = "effectiveMemberName"; + public static final String OWNED_MEMBER_ELEMENT_ID = "ownedMemberElementId"; public static final String MEMBER_NAME = "memberName"; public static final String OWNED_RELATED_ELEMENT = "ownedRelatedElement"; public static final String SOURCE = "source"; + public static final String MEMBER_ELEMENT_ID = "memberElementId"; public static final String TARGET = "target"; - public static final String HUMAN_ID = "humanId"; - public static final String ALIAS_ID = "aliasId"; public static final String RELATED_ELEMENT = "relatedElement"; public static final String NAME = "name"; + public static final String MEMBER_SHORT_NAME = "memberShortName"; + public static final String OWNED_MEMBER_NAME = "ownedMemberName"; + public static final String SHORT_NAME = "shortName"; public static final String EFFECTIVE_NAME = "effectiveName"; + public static final String OWNED_MEMBER_SHORT_NAME = "ownedMemberShortName"; } diff --git a/generated/org/omg/sysml/metamodel/impl/ViewUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ViewUsageImpl_.java index 592a83c5..76a0ea14 100644 --- a/generated/org/omg/sysml/metamodel/impl/ViewUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ViewUsageImpl_.java @@ -84,8 +84,8 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -105,6 +105,7 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -138,6 +139,7 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile ListAttribute partDefinition; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute viewedElement; @@ -149,9 +151,7 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static volatile ListAttribute itemDefinition; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -177,8 +177,8 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -198,6 +198,7 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -231,6 +232,7 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; public static final String PART_DEFINITION = "partDefinition"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String VIEWED_ELEMENT = "viewedElement"; @@ -242,9 +244,7 @@ public abstract class ViewUsageImpl_ extends org.omg.sysml.lifecycle.impl.DataIm public static final String ITEM_DEFINITION = "itemDefinition"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/generated/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl_.java b/generated/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl_.java index 31cf17af..5d35ee6a 100644 --- a/generated/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ViewpointDefinitionImpl_.java @@ -69,8 +69,8 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute ownedItem; public static volatile CollectionAttribute text; public static volatile SingularAttribute isSufficient; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute ownedAnnotation; public static volatile ListAttribute ownedView; public static volatile ListAttribute ownedFeature; @@ -93,6 +93,7 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile SingularAttribute name; public static volatile ListAttribute ownedReference; public static volatile ListAttribute ownedUsage; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute ownedMembership; public static volatile ListAttribute ownedUseCase; @@ -116,6 +117,7 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute ownedElement; public static volatile CollectionAttribute expression; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute ownedConnection; public static volatile ListAttribute featureMembership; @@ -123,8 +125,6 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static volatile ListAttribute ownedRequirement; public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; - public static volatile SingularAttribute humanId; - public static volatile ListAttribute aliasId; public static volatile ListAttribute ownedSpecialization; public static volatile CollectionAttribute ownedConcern; public static volatile CollectionAttribute step; @@ -148,8 +148,8 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String OWNED_ITEM = "ownedItem"; public static final String TEXT = "text"; public static final String IS_SUFFICIENT = "isSufficient"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String OWNED_VIEW = "ownedView"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -172,6 +172,7 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String NAME = "name"; public static final String OWNED_REFERENCE = "ownedReference"; public static final String OWNED_USAGE = "ownedUsage"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; public static final String OWNED_USE_CASE = "ownedUseCase"; @@ -195,6 +196,7 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String OWNED_ELEMENT = "ownedElement"; public static final String EXPRESSION = "expression"; public static final String IS_MODEL_LEVEL_EVALUABLE = "isModelLevelEvaluable"; + public static final String ALIAS_IDS = "aliasIds"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String OWNED_CONNECTION = "ownedConnection"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -202,8 +204,6 @@ public abstract class ViewpointDefinitionImpl_ extends org.omg.sysml.lifecycle.i public static final String OWNED_REQUIREMENT = "ownedRequirement"; public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - 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 OWNED_CONCERN = "ownedConcern"; public static final String STEP = "step"; diff --git a/generated/org/omg/sysml/metamodel/impl/ViewpointUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/ViewpointUsageImpl_.java index 7d26896d..b682b468 100644 --- a/generated/org/omg/sysml/metamodel/impl/ViewpointUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/ViewpointUsageImpl_.java @@ -75,7 +75,6 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile SingularAttribute isSufficient; public static volatile CollectionAttribute ownedRedefinition; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute nestedEnumeration; public static volatile ListAttribute ownedFeature; @@ -88,6 +87,7 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute nestedCalculation; public static volatile ListAttribute actorParameter; public static volatile ListAttribute nestedView; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute nestedAllocation; @@ -105,11 +105,11 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; public static volatile SingularAttribute isModelLevelEvaluable; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute featureMembership; public static volatile SingularAttribute portionKind; public static volatile SingularAttribute isAbstract; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; @@ -123,6 +123,7 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute variant; public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; + public static volatile SingularAttribute elementId; public static volatile SingularAttribute isDerived; public static volatile ListAttribute ownedAnnotation; public static volatile SingularAttribute qualifiedName; @@ -156,7 +157,6 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static volatile CollectionAttribute nestedConcern; public static volatile ListAttribute ownedImport; public static volatile CollectionAttribute variantMembership; - public static volatile ListAttribute aliasId; public static final String OWNED_TYPE_FEATURING = "ownedTypeFeaturing"; public static final String REQUIRED_CONSTRAINT = "requiredConstraint"; @@ -173,7 +173,6 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String IS_SUFFICIENT = "isSufficient"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String NESTED_ENUMERATION = "nestedEnumeration"; public static final String OWNED_FEATURE = "ownedFeature"; @@ -186,6 +185,7 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NESTED_CALCULATION = "nestedCalculation"; public static final String ACTOR_PARAMETER = "actorParameter"; public static final String NESTED_VIEW = "nestedView"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String NESTED_ALLOCATION = "nestedAllocation"; @@ -203,11 +203,11 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D 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 ALIAS_IDS = "aliasIds"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; public static final String PORTION_KIND = "portionKind"; public static final String IS_ABSTRACT = "isAbstract"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; @@ -221,6 +221,7 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String VARIANT = "variant"; public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; + public static final String ELEMENT_ID = "elementId"; public static final String IS_DERIVED = "isDerived"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; public static final String QUALIFIED_NAME = "qualifiedName"; @@ -254,7 +255,6 @@ public abstract class ViewpointUsageImpl_ extends org.omg.sysml.lifecycle.impl.D public static final String NESTED_CONCERN = "nestedConcern"; public static final String OWNED_IMPORT = "ownedImport"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; - public static final String ALIAS_ID = "aliasId"; } diff --git a/generated/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl_.java b/generated/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl_.java index 2f900bd5..e9e1c313 100644 --- a/generated/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl_.java +++ b/generated/org/omg/sysml/metamodel/impl/WhileLoopActionUsageImpl_.java @@ -80,8 +80,8 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile ListAttribute nestedState; public static volatile SingularAttribute isOrdered; public static volatile CollectionAttribute ownedRedefinition; + public static volatile SingularAttribute elementId; public static volatile ListAttribute textualRepresentation; - public static volatile SingularAttribute identifier; public static volatile SingularAttribute isDerived; public static volatile ListAttribute nestedAttribute; public static volatile ListAttribute ownedAnnotation; @@ -102,6 +102,7 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute isComposite; public static volatile ListAttribute nestedView; public static volatile SingularAttribute name; + public static volatile SingularAttribute shortName; public static volatile ListAttribute ownedMember; public static volatile ListAttribute nestedOccurrence; public static volatile ListAttribute ownedMembership; @@ -134,6 +135,7 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute direction; public static volatile ListAttribute importedMembership; public static volatile ListAttribute ownedElement; + public static volatile ListAttribute aliasIds; public static volatile ListAttribute nestedAction; public static volatile ListAttribute ownedRelationship; public static volatile ListAttribute featureMembership; @@ -143,9 +145,7 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static volatile SingularAttribute isAbstract; public static volatile CollectionAttribute variantMembership; public static volatile ListAttribute nestedRendering; - public static volatile SingularAttribute humanId; public static volatile ListAttribute nestedConnection; - public static volatile ListAttribute aliasId; public static volatile ListAttribute nestedInterface; public static volatile ListAttribute ownedSpecialization; public static volatile ListAttribute nestedViewpoint; @@ -170,8 +170,8 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static final String NESTED_STATE = "nestedState"; public static final String IS_ORDERED = "isOrdered"; public static final String OWNED_REDEFINITION = "ownedRedefinition"; + public static final String ELEMENT_ID = "elementId"; public static final String TEXTUAL_REPRESENTATION = "textualRepresentation"; - public static final String IDENTIFIER = "identifier"; public static final String IS_DERIVED = "isDerived"; public static final String NESTED_ATTRIBUTE = "nestedAttribute"; public static final String OWNED_ANNOTATION = "ownedAnnotation"; @@ -192,6 +192,7 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static final String IS_COMPOSITE = "isComposite"; public static final String NESTED_VIEW = "nestedView"; public static final String NAME = "name"; + public static final String SHORT_NAME = "shortName"; public static final String OWNED_MEMBER = "ownedMember"; public static final String NESTED_OCCURRENCE = "nestedOccurrence"; public static final String OWNED_MEMBERSHIP = "ownedMembership"; @@ -224,6 +225,7 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static final String DIRECTION = "direction"; public static final String IMPORTED_MEMBERSHIP = "importedMembership"; public static final String OWNED_ELEMENT = "ownedElement"; + public static final String ALIAS_IDS = "aliasIds"; public static final String NESTED_ACTION = "nestedAction"; public static final String OWNED_RELATIONSHIP = "ownedRelationship"; public static final String FEATURE_MEMBERSHIP = "featureMembership"; @@ -233,9 +235,7 @@ public abstract class WhileLoopActionUsageImpl_ extends org.omg.sysml.lifecycle. public static final String IS_ABSTRACT = "isAbstract"; public static final String VARIANT_MEMBERSHIP = "variantMembership"; public static final String NESTED_RENDERING = "nestedRendering"; - public static final String HUMAN_ID = "humanId"; public static final String NESTED_CONNECTION = "nestedConnection"; - public static final String ALIAS_ID = "aliasId"; public static final String NESTED_INTERFACE = "nestedInterface"; public static final String OWNED_SPECIALIZATION = "ownedSpecialization"; public static final String NESTED_VIEWPOINT = "nestedViewpoint"; diff --git a/public/jsonld/metamodel/AcceptActionUsage.jsonld b/public/jsonld/metamodel/AcceptActionUsage.jsonld index e3e80145..938e6d22 100644 --- a/public/jsonld/metamodel/AcceptActionUsage.jsonld +++ b/public/jsonld/metamodel/AcceptActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -105,6 +104,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "receiverArgument": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ActionDefinition.jsonld b/public/jsonld/metamodel/ActionDefinition.jsonld index ef6f6f6d..d7bfa0b2 100644 --- a/public/jsonld/metamodel/ActionDefinition.jsonld +++ b/public/jsonld/metamodel/ActionDefinition.jsonld @@ -6,16 +6,15 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "action": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -76,6 +75,7 @@ "owningRelationship": {"@type": "@id"}, "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ActionUsage.jsonld b/public/jsonld/metamodel/ActionUsage.jsonld index 53acf605..990fe08b 100644 --- a/public/jsonld/metamodel/ActionUsage.jsonld +++ b/public/jsonld/metamodel/ActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ActorMembership.jsonld b/public/jsonld/metamodel/ActorMembership.jsonld index d7b6da71..3cae8e47 100644 --- a/public/jsonld/metamodel/ActorMembership.jsonld +++ b/public/jsonld/metamodel/ActorMembership.jsonld @@ -5,26 +5,27 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, - "memberParameter": {"@type": "@id"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedActorParameter": {"@type": "@id"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, "ownedMemberParameter": {"@type": "@id"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -36,6 +37,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AllocationDefinition.jsonld b/public/jsonld/metamodel/AllocationDefinition.jsonld index 01f2ac9e..98672d9d 100644 --- a/public/jsonld/metamodel/AllocationDefinition.jsonld +++ b/public/jsonld/metamodel/AllocationDefinition.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "allocation": {"@type": "@id"}, "associationEnd": {"@type": "@id"}, "connectionEnd": {"@type": "@id"}, @@ -13,11 +13,10 @@ "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -81,6 +80,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedType": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceType": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AllocationUsage.jsonld b/public/jsonld/metamodel/AllocationUsage.jsonld index 280797c8..fad68836 100644 --- a/public/jsonld/metamodel/AllocationUsage.jsonld +++ b/public/jsonld/metamodel/AllocationUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "allocationDefinition": {"@type": "@id"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -17,13 +17,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -110,6 +109,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AnalysisCaseDefinition.jsonld b/public/jsonld/metamodel/AnalysisCaseDefinition.jsonld index c1fc843c..e4e55775 100644 --- a/public/jsonld/metamodel/AnalysisCaseDefinition.jsonld +++ b/public/jsonld/metamodel/AnalysisCaseDefinition.jsonld @@ -7,19 +7,18 @@ "action": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "analysisAction": {"@type": "@id"}, "calculation": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -84,6 +83,7 @@ "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, "resultExpression": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AnalysisCaseUsage.jsonld b/public/jsonld/metamodel/AnalysisCaseUsage.jsonld index 3bd150f0..46a6e2c5 100644 --- a/public/jsonld/metamodel/AnalysisCaseUsage.jsonld +++ b/public/jsonld/metamodel/AnalysisCaseUsage.jsonld @@ -7,7 +7,7 @@ "actionDefinition": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "analysisAction": {"@type": "@id"}, "analysisCaseDefinition": {"@type": "@id"}, "behavior": {"@type": "@id"}, @@ -20,14 +20,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -112,6 +111,7 @@ "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, "resultExpression": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AnnotatingElement.jsonld b/public/jsonld/metamodel/AnnotatingElement.jsonld index f1ca43b7..2860dddc 100644 --- a/public/jsonld/metamodel/AnnotatingElement.jsonld +++ b/public/jsonld/metamodel/AnnotatingElement.jsonld @@ -5,13 +5,12 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotation": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -21,6 +20,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/Annotation.jsonld b/public/jsonld/metamodel/Annotation.jsonld index 46f95cc1..a4015719 100644 --- a/public/jsonld/metamodel/Annotation.jsonld +++ b/public/jsonld/metamodel/Annotation.jsonld @@ -5,13 +5,12 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotatingElement": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/AssertConstraintUsage.jsonld b/public/jsonld/metamodel/AssertConstraintUsage.jsonld index bf2cca5d..45a5a905 100644 --- a/public/jsonld/metamodel/AssertConstraintUsage.jsonld +++ b/public/jsonld/metamodel/AssertConstraintUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assertedConstraint": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -16,14 +16,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -108,6 +107,7 @@ "predicate": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AssignmentActionUsage.jsonld b/public/jsonld/metamodel/AssignmentActionUsage.jsonld index a7fc620b..61d7ac41 100644 --- a/public/jsonld/metamodel/AssignmentActionUsage.jsonld +++ b/public/jsonld/metamodel/AssignmentActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -103,6 +102,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "referent": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "targetArgument": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Association.jsonld b/public/jsonld/metamodel/Association.jsonld index 87671f53..effdf909 100644 --- a/public/jsonld/metamodel/Association.jsonld +++ b/public/jsonld/metamodel/Association.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "associationEnd": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -49,6 +48,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedType": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceType": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AssociationStructure.jsonld b/public/jsonld/metamodel/AssociationStructure.jsonld index 87671f53..effdf909 100644 --- a/public/jsonld/metamodel/AssociationStructure.jsonld +++ b/public/jsonld/metamodel/AssociationStructure.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "associationEnd": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -49,6 +48,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedType": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceType": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AttributeDefinition.jsonld b/public/jsonld/metamodel/AttributeDefinition.jsonld index 2068af23..288fbc63 100644 --- a/public/jsonld/metamodel/AttributeDefinition.jsonld +++ b/public/jsonld/metamodel/AttributeDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -72,6 +71,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/AttributeUsage.jsonld b/public/jsonld/metamodel/AttributeUsage.jsonld index 9556ff38..9a9a81b0 100644 --- a/public/jsonld/metamodel/AttributeUsage.jsonld +++ b/public/jsonld/metamodel/AttributeUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "attributeDefinition": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -14,13 +14,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -95,6 +94,7 @@ "owningType": {"@type": "@id"}, "owningUsage": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Behavior.jsonld b/public/jsonld/metamodel/Behavior.jsonld index bd36fd4f..8499fadb 100644 --- a/public/jsonld/metamodel/Behavior.jsonld +++ b/public/jsonld/metamodel/Behavior.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -45,6 +44,7 @@ "owningRelationship": {"@type": "@id"}, "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/BindingConnector.jsonld b/public/jsonld/metamodel/BindingConnector.jsonld index d5d88d9a..a4e5a1ed 100644 --- a/public/jsonld/metamodel/BindingConnector.jsonld +++ b/public/jsonld/metamodel/BindingConnector.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectorEnd": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -69,6 +68,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/BindingConnectorAsUsage.jsonld b/public/jsonld/metamodel/BindingConnectorAsUsage.jsonld index f49c4878..93a5f750 100644 --- a/public/jsonld/metamodel/BindingConnectorAsUsage.jsonld +++ b/public/jsonld/metamodel/BindingConnectorAsUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectorEnd": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -101,6 +100,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/BooleanExpression.jsonld b/public/jsonld/metamodel/BooleanExpression.jsonld index fd70582d..bfe94f85 100644 --- a/public/jsonld/metamodel/BooleanExpression.jsonld +++ b/public/jsonld/metamodel/BooleanExpression.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -68,6 +67,7 @@ "predicate": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/CalculationDefinition.jsonld b/public/jsonld/metamodel/CalculationDefinition.jsonld index 8048160e..4fc2daa5 100644 --- a/public/jsonld/metamodel/CalculationDefinition.jsonld +++ b/public/jsonld/metamodel/CalculationDefinition.jsonld @@ -6,18 +6,17 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "action": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "calculation": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -80,6 +79,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/CalculationUsage.jsonld b/public/jsonld/metamodel/CalculationUsage.jsonld index 40e73247..d988c4d8 100644 --- a/public/jsonld/metamodel/CalculationUsage.jsonld +++ b/public/jsonld/metamodel/CalculationUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "calculationDefinition": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -16,14 +16,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -106,6 +105,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/CaseDefinition.jsonld b/public/jsonld/metamodel/CaseDefinition.jsonld index fb8948af..972f451a 100644 --- a/public/jsonld/metamodel/CaseDefinition.jsonld +++ b/public/jsonld/metamodel/CaseDefinition.jsonld @@ -7,18 +7,17 @@ "action": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "calculation": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -82,6 +81,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/CaseUsage.jsonld b/public/jsonld/metamodel/CaseUsage.jsonld index 84f01d64..9e85e606 100644 --- a/public/jsonld/metamodel/CaseUsage.jsonld +++ b/public/jsonld/metamodel/CaseUsage.jsonld @@ -7,7 +7,7 @@ "actionDefinition": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "calculationDefinition": {"@type": "@id"}, "caseDefinition": {"@type": "@id"}, @@ -18,14 +18,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -109,6 +108,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Class.jsonld b/public/jsonld/metamodel/Class.jsonld index 5bb0080b..15b23fce 100644 --- a/public/jsonld/metamodel/Class.jsonld +++ b/public/jsonld/metamodel/Class.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -44,6 +43,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/Classifier.jsonld b/public/jsonld/metamodel/Classifier.jsonld index 5bb0080b..15b23fce 100644 --- a/public/jsonld/metamodel/Classifier.jsonld +++ b/public/jsonld/metamodel/Classifier.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -44,6 +43,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/CollectExpression.jsonld b/public/jsonld/metamodel/CollectExpression.jsonld index 1701f8f3..40796f6e 100644 --- a/public/jsonld/metamodel/CollectExpression.jsonld +++ b/public/jsonld/metamodel/CollectExpression.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "argument": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -70,6 +69,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Comment.jsonld b/public/jsonld/metamodel/Comment.jsonld index 9cc9ef5c..fadd6cf0 100644 --- a/public/jsonld/metamodel/Comment.jsonld +++ b/public/jsonld/metamodel/Comment.jsonld @@ -5,14 +5,13 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotation": {"@type": "@id"}, "body": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "locale": {"@type": "xsd:string"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, @@ -23,6 +22,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/ConcernDefinition.jsonld b/public/jsonld/metamodel/ConcernDefinition.jsonld index dc84a8b8..d8ea0ff7 100644 --- a/public/jsonld/metamodel/ConcernDefinition.jsonld +++ b/public/jsonld/metamodel/ConcernDefinition.jsonld @@ -6,19 +6,18 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assumedConstraint": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -83,6 +82,7 @@ "reqId": {"@type": "xsd:string"}, "requiredConstraint": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ConcernUsage.jsonld b/public/jsonld/metamodel/ConcernUsage.jsonld index ad625114..96e7e9e4 100644 --- a/public/jsonld/metamodel/ConcernUsage.jsonld +++ b/public/jsonld/metamodel/ConcernUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assumedConstraint": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -18,6 +18,7 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, @@ -25,8 +26,6 @@ "featuringType": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, "function": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -113,6 +112,7 @@ "requiredConstraint": {"@type": "@id"}, "requirementDefinition": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "text": {"@type": "xsd:string"}, diff --git a/public/jsonld/metamodel/ConjugatedPortDefinition.jsonld b/public/jsonld/metamodel/ConjugatedPortDefinition.jsonld index 170025a6..9c413172 100644 --- a/public/jsonld/metamodel/ConjugatedPortDefinition.jsonld +++ b/public/jsonld/metamodel/ConjugatedPortDefinition.jsonld @@ -5,17 +5,16 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "conjugatedPortDefinition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -77,6 +76,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ConjugatedPortTyping.jsonld b/public/jsonld/metamodel/ConjugatedPortTyping.jsonld index 0c8314cc..a8ce59d4 100644 --- a/public/jsonld/metamodel/ConjugatedPortTyping.jsonld +++ b/public/jsonld/metamodel/ConjugatedPortTyping.jsonld @@ -5,13 +5,12 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "conjugatedPortDefinition": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "general": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -27,6 +26,7 @@ "portDefinition": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "specific": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Conjugation.jsonld b/public/jsonld/metamodel/Conjugation.jsonld index 47c1a27c..125e3153 100644 --- a/public/jsonld/metamodel/Conjugation.jsonld +++ b/public/jsonld/metamodel/Conjugation.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "conjugatedType": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "originalType": {"@type": "@id"}, "ownedAnnotation": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/ConnectionDefinition.jsonld b/public/jsonld/metamodel/ConnectionDefinition.jsonld index ffd962ed..9bd8ac84 100644 --- a/public/jsonld/metamodel/ConnectionDefinition.jsonld +++ b/public/jsonld/metamodel/ConnectionDefinition.jsonld @@ -5,18 +5,17 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "associationEnd": {"@type": "@id"}, "connectionEnd": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -80,6 +79,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedType": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceType": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ConnectionUsage.jsonld b/public/jsonld/metamodel/ConnectionUsage.jsonld index 3c91f6b7..0eb82289 100644 --- a/public/jsonld/metamodel/ConnectionUsage.jsonld +++ b/public/jsonld/metamodel/ConnectionUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectionDefinition": {"@type": "@id"}, @@ -16,13 +16,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -109,6 +108,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Connector.jsonld b/public/jsonld/metamodel/Connector.jsonld index d5d88d9a..a4e5a1ed 100644 --- a/public/jsonld/metamodel/Connector.jsonld +++ b/public/jsonld/metamodel/Connector.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectorEnd": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -69,6 +68,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ConnectorAsUsage.jsonld b/public/jsonld/metamodel/ConnectorAsUsage.jsonld index f49c4878..93a5f750 100644 --- a/public/jsonld/metamodel/ConnectorAsUsage.jsonld +++ b/public/jsonld/metamodel/ConnectorAsUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectorEnd": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -101,6 +100,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ConstraintDefinition.jsonld b/public/jsonld/metamodel/ConstraintDefinition.jsonld index ae110e92..e4e3636f 100644 --- a/public/jsonld/metamodel/ConstraintDefinition.jsonld +++ b/public/jsonld/metamodel/ConstraintDefinition.jsonld @@ -5,17 +5,16 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -78,6 +77,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ConstraintUsage.jsonld b/public/jsonld/metamodel/ConstraintUsage.jsonld index 6588b23a..128d4302 100644 --- a/public/jsonld/metamodel/ConstraintUsage.jsonld +++ b/public/jsonld/metamodel/ConstraintUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "constraintDefinition": {"@type": "@id"}, @@ -15,14 +15,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -106,6 +105,7 @@ "predicate": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ControlNode.jsonld b/public/jsonld/metamodel/ControlNode.jsonld index 53acf605..990fe08b 100644 --- a/public/jsonld/metamodel/ControlNode.jsonld +++ b/public/jsonld/metamodel/ControlNode.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/DataType.jsonld b/public/jsonld/metamodel/DataType.jsonld index 5bb0080b..15b23fce 100644 --- a/public/jsonld/metamodel/DataType.jsonld +++ b/public/jsonld/metamodel/DataType.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -44,6 +43,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/DecisionNode.jsonld b/public/jsonld/metamodel/DecisionNode.jsonld index 53acf605..990fe08b 100644 --- a/public/jsonld/metamodel/DecisionNode.jsonld +++ b/public/jsonld/metamodel/DecisionNode.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Definition.jsonld b/public/jsonld/metamodel/Definition.jsonld index 2068af23..288fbc63 100644 --- a/public/jsonld/metamodel/Definition.jsonld +++ b/public/jsonld/metamodel/Definition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -72,6 +71,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Dependency.jsonld b/public/jsonld/metamodel/Dependency.jsonld index d5d15eb2..48f84915 100644 --- a/public/jsonld/metamodel/Dependency.jsonld +++ b/public/jsonld/metamodel/Dependency.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "client": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -23,6 +22,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "supplier": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Disjoining.jsonld b/public/jsonld/metamodel/Disjoining.jsonld index d512b545..668f18fc 100644 --- a/public/jsonld/metamodel/Disjoining.jsonld +++ b/public/jsonld/metamodel/Disjoining.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "disjoiningType": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -24,6 +23,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Documentation.jsonld b/public/jsonld/metamodel/Documentation.jsonld index 692decf6..c805facf 100644 --- a/public/jsonld/metamodel/Documentation.jsonld +++ b/public/jsonld/metamodel/Documentation.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotation": {"@type": "@id"}, "body": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "documentedElement": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "locale": {"@type": "xsd:string"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, @@ -24,6 +23,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/Element.jsonld b/public/jsonld/metamodel/Element.jsonld index 8b808d69..f1cb7297 100644 --- a/public/jsonld/metamodel/Element.jsonld +++ b/public/jsonld/metamodel/Element.jsonld @@ -5,11 +5,10 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -19,6 +18,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/ElementFilterMembership.jsonld b/public/jsonld/metamodel/ElementFilterMembership.jsonld index a77ceb92..51214c24 100644 --- a/public/jsonld/metamodel/ElementFilterMembership.jsonld +++ b/public/jsonld/metamodel/ElementFilterMembership.jsonld @@ -5,20 +5,23 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "condition": {"@type": "@id"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -28,6 +31,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/EndFeatureMembership.jsonld b/public/jsonld/metamodel/EndFeatureMembership.jsonld index 13e74f71..33d6e9c3 100644 --- a/public/jsonld/metamodel/EndFeatureMembership.jsonld +++ b/public/jsonld/metamodel/EndFeatureMembership.jsonld @@ -5,23 +5,25 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -33,6 +35,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/EnumerationDefinition.jsonld b/public/jsonld/metamodel/EnumerationDefinition.jsonld index 6c541089..cd491efd 100644 --- a/public/jsonld/metamodel/EnumerationDefinition.jsonld +++ b/public/jsonld/metamodel/EnumerationDefinition.jsonld @@ -5,17 +5,16 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "enumeratedValue": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -73,6 +72,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/EnumerationUsage.jsonld b/public/jsonld/metamodel/EnumerationUsage.jsonld index 62c90432..7ecbbcf8 100644 --- a/public/jsonld/metamodel/EnumerationUsage.jsonld +++ b/public/jsonld/metamodel/EnumerationUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "attributeDefinition": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -14,14 +14,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "enumerationDefinition": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -96,6 +95,7 @@ "owningType": {"@type": "@id"}, "owningUsage": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/EventOccurrenceUsage.jsonld b/public/jsonld/metamodel/EventOccurrenceUsage.jsonld index 5ad03171..1f085dca 100644 --- a/public/jsonld/metamodel/EventOccurrenceUsage.jsonld +++ b/public/jsonld/metamodel/EventOccurrenceUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "eventOccurrence": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -100,6 +99,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ExhibitStateUsage.jsonld b/public/jsonld/metamodel/ExhibitStateUsage.jsonld index ab56e3e1..42a6abb5 100644 --- a/public/jsonld/metamodel/ExhibitStateUsage.jsonld +++ b/public/jsonld/metamodel/ExhibitStateUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -16,6 +16,7 @@ "doAction": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "entryAction": {"@type": "@id"}, @@ -25,8 +26,6 @@ "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -109,6 +108,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "stateDefinition": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Expose.jsonld b/public/jsonld/metamodel/Expose.jsonld index c5f7454b..ed64220f 100644 --- a/public/jsonld/metamodel/Expose.jsonld +++ b/public/jsonld/metamodel/Expose.jsonld @@ -5,11 +5,10 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "importOwningNamespace": {"@type": "@id"}, "importedMemberName": {"@type": "xsd:string"}, "importedNamespace": {"@type": "@id"}, @@ -27,6 +26,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Expression.jsonld b/public/jsonld/metamodel/Expression.jsonld index 98895b32..12567047 100644 --- a/public/jsonld/metamodel/Expression.jsonld +++ b/public/jsonld/metamodel/Expression.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Feature.jsonld b/public/jsonld/metamodel/Feature.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/Feature.jsonld +++ b/public/jsonld/metamodel/Feature.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/FeatureChainExpression.jsonld b/public/jsonld/metamodel/FeatureChainExpression.jsonld index 11291a13..1f973072 100644 --- a/public/jsonld/metamodel/FeatureChainExpression.jsonld +++ b/public/jsonld/metamodel/FeatureChainExpression.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "argument": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -70,6 +69,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "targetFeature": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/FeatureChaining.jsonld b/public/jsonld/metamodel/FeatureChaining.jsonld index 6f9916d6..515a3945 100644 --- a/public/jsonld/metamodel/FeatureChaining.jsonld +++ b/public/jsonld/metamodel/FeatureChaining.jsonld @@ -5,13 +5,12 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureChained": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -24,6 +23,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/FeatureMembership.jsonld b/public/jsonld/metamodel/FeatureMembership.jsonld index 13e74f71..33d6e9c3 100644 --- a/public/jsonld/metamodel/FeatureMembership.jsonld +++ b/public/jsonld/metamodel/FeatureMembership.jsonld @@ -5,23 +5,25 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -33,6 +35,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/FeatureReferenceExpression.jsonld b/public/jsonld/metamodel/FeatureReferenceExpression.jsonld index 9ad3700a..93ea4cbe 100644 --- a/public/jsonld/metamodel/FeatureReferenceExpression.jsonld +++ b/public/jsonld/metamodel/FeatureReferenceExpression.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -68,6 +67,7 @@ "qualifiedName": {"@type": "xsd:string"}, "referent": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/FeatureTyping.jsonld b/public/jsonld/metamodel/FeatureTyping.jsonld index 7b401370..34a79069 100644 --- a/public/jsonld/metamodel/FeatureTyping.jsonld +++ b/public/jsonld/metamodel/FeatureTyping.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "general": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "specific": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/FeatureValue.jsonld b/public/jsonld/metamodel/FeatureValue.jsonld index 1cc8b7bd..8f51d489 100644 --- a/public/jsonld/metamodel/FeatureValue.jsonld +++ b/public/jsonld/metamodel/FeatureValue.jsonld @@ -5,22 +5,25 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureWithValue": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "isDefault": {"@type": "xsd:boolean"}, "isInitial": {"@type": "xsd:boolean"}, "memberElement": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -30,6 +33,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/FlowConnectionUsage.jsonld b/public/jsonld/metamodel/FlowConnectionUsage.jsonld index f9e1ec6c..918a91f0 100644 --- a/public/jsonld/metamodel/FlowConnectionUsage.jsonld +++ b/public/jsonld/metamodel/FlowConnectionUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -17,13 +17,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -115,6 +114,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "sourceOutputFeature": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ForLoopActionUsage.jsonld b/public/jsonld/metamodel/ForLoopActionUsage.jsonld index 337c7050..57699782 100644 --- a/public/jsonld/metamodel/ForLoopActionUsage.jsonld +++ b/public/jsonld/metamodel/ForLoopActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "bodyAction": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -16,13 +16,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -105,6 +104,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "seqArgument": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ForkNode.jsonld b/public/jsonld/metamodel/ForkNode.jsonld index 53acf605..990fe08b 100644 --- a/public/jsonld/metamodel/ForkNode.jsonld +++ b/public/jsonld/metamodel/ForkNode.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/FramedConcernMembership.jsonld b/public/jsonld/metamodel/FramedConcernMembership.jsonld index f31dd3f7..0a07f2b7 100644 --- a/public/jsonld/metamodel/FramedConcernMembership.jsonld +++ b/public/jsonld/metamodel/FramedConcernMembership.jsonld @@ -5,18 +5,17 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "kind": {"@type": "@vocab"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, @@ -24,7 +23,10 @@ "ownedConstraint": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -38,6 +40,7 @@ "referencedConcern": {"@type": "@id"}, "referencedConstraint": {"@type": "@id"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Function.jsonld b/public/jsonld/metamodel/Function.jsonld index 0b9795cb..4066e511 100644 --- a/public/jsonld/metamodel/Function.jsonld +++ b/public/jsonld/metamodel/Function.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -48,6 +47,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/IfActionUsage.jsonld b/public/jsonld/metamodel/IfActionUsage.jsonld index 7c454c5a..8fb4f6a3 100644 --- a/public/jsonld/metamodel/IfActionUsage.jsonld +++ b/public/jsonld/metamodel/IfActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,14 +15,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "elseAction": {"@type": "@id"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "ifArgument": {"@type": "@id"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, @@ -104,6 +103,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "thenAction": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Import.jsonld b/public/jsonld/metamodel/Import.jsonld index c5f7454b..ed64220f 100644 --- a/public/jsonld/metamodel/Import.jsonld +++ b/public/jsonld/metamodel/Import.jsonld @@ -5,11 +5,10 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "importOwningNamespace": {"@type": "@id"}, "importedMemberName": {"@type": "xsd:string"}, "importedNamespace": {"@type": "@id"}, @@ -27,6 +26,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/IncludeUseCaseUsage.jsonld b/public/jsonld/metamodel/IncludeUseCaseUsage.jsonld index 18410840..c43c2ffa 100644 --- a/public/jsonld/metamodel/IncludeUseCaseUsage.jsonld +++ b/public/jsonld/metamodel/IncludeUseCaseUsage.jsonld @@ -7,7 +7,7 @@ "actionDefinition": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "calculationDefinition": {"@type": "@id"}, "caseDefinition": {"@type": "@id"}, @@ -18,6 +18,7 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "eventOccurrence": {"@type": "@id"}, @@ -25,8 +26,6 @@ "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, "function": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "includedUseCase": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, @@ -112,6 +111,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Interaction.jsonld b/public/jsonld/metamodel/Interaction.jsonld index db4d0449..21781644 100644 --- a/public/jsonld/metamodel/Interaction.jsonld +++ b/public/jsonld/metamodel/Interaction.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "associationEnd": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -50,6 +49,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedType": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceType": {"@type": "@id"}, "step": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/InterfaceDefinition.jsonld b/public/jsonld/metamodel/InterfaceDefinition.jsonld index 0f8492b5..f6c68f1f 100644 --- a/public/jsonld/metamodel/InterfaceDefinition.jsonld +++ b/public/jsonld/metamodel/InterfaceDefinition.jsonld @@ -5,18 +5,17 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "associationEnd": {"@type": "@id"}, "connectionEnd": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -81,6 +80,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedType": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceType": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/InterfaceUsage.jsonld b/public/jsonld/metamodel/InterfaceUsage.jsonld index dd421ad0..b8f73127 100644 --- a/public/jsonld/metamodel/InterfaceUsage.jsonld +++ b/public/jsonld/metamodel/InterfaceUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectionDefinition": {"@type": "@id"}, @@ -16,13 +16,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -110,6 +109,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Invariant.jsonld b/public/jsonld/metamodel/Invariant.jsonld index 28a8079f..12d11662 100644 --- a/public/jsonld/metamodel/Invariant.jsonld +++ b/public/jsonld/metamodel/Invariant.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -69,6 +68,7 @@ "predicate": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/InvocationExpression.jsonld b/public/jsonld/metamodel/InvocationExpression.jsonld index 5f70befe..a7b7e305 100644 --- a/public/jsonld/metamodel/InvocationExpression.jsonld +++ b/public/jsonld/metamodel/InvocationExpression.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "argument": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -68,6 +67,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/ItemDefinition.jsonld b/public/jsonld/metamodel/ItemDefinition.jsonld index 0118d9e4..5d27479a 100644 --- a/public/jsonld/metamodel/ItemDefinition.jsonld +++ b/public/jsonld/metamodel/ItemDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -74,6 +73,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ItemFeature.jsonld b/public/jsonld/metamodel/ItemFeature.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/ItemFeature.jsonld +++ b/public/jsonld/metamodel/ItemFeature.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/ItemFlow.jsonld b/public/jsonld/metamodel/ItemFlow.jsonld index f62e40f0..6a062ee8 100644 --- a/public/jsonld/metamodel/ItemFlow.jsonld +++ b/public/jsonld/metamodel/ItemFlow.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -14,13 +14,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -75,6 +74,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "sourceOutputFeature": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ItemFlowEnd.jsonld b/public/jsonld/metamodel/ItemFlowEnd.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/ItemFlowEnd.jsonld +++ b/public/jsonld/metamodel/ItemFlowEnd.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/ItemFlowFeature.jsonld b/public/jsonld/metamodel/ItemFlowFeature.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/ItemFlowFeature.jsonld +++ b/public/jsonld/metamodel/ItemFlowFeature.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/ItemUsage.jsonld b/public/jsonld/metamodel/ItemUsage.jsonld index 6aedd532..0d8d40d2 100644 --- a/public/jsonld/metamodel/ItemUsage.jsonld +++ b/public/jsonld/metamodel/ItemUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -100,6 +99,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/JoinNode.jsonld b/public/jsonld/metamodel/JoinNode.jsonld index 53acf605..990fe08b 100644 --- a/public/jsonld/metamodel/JoinNode.jsonld +++ b/public/jsonld/metamodel/JoinNode.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/LifeClass.jsonld b/public/jsonld/metamodel/LifeClass.jsonld index 5bb0080b..15b23fce 100644 --- a/public/jsonld/metamodel/LifeClass.jsonld +++ b/public/jsonld/metamodel/LifeClass.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -44,6 +43,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/LiteralBoolean.jsonld b/public/jsonld/metamodel/LiteralBoolean.jsonld index a254e66a..9d413dbc 100644 --- a/public/jsonld/metamodel/LiteralBoolean.jsonld +++ b/public/jsonld/metamodel/LiteralBoolean.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "value": {"@type": "xsd:boolean"} diff --git a/public/jsonld/metamodel/LiteralExpression.jsonld b/public/jsonld/metamodel/LiteralExpression.jsonld index 98895b32..12567047 100644 --- a/public/jsonld/metamodel/LiteralExpression.jsonld +++ b/public/jsonld/metamodel/LiteralExpression.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/LiteralInfinity.jsonld b/public/jsonld/metamodel/LiteralInfinity.jsonld index 98895b32..12567047 100644 --- a/public/jsonld/metamodel/LiteralInfinity.jsonld +++ b/public/jsonld/metamodel/LiteralInfinity.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/LiteralInteger.jsonld b/public/jsonld/metamodel/LiteralInteger.jsonld index 984d5336..ae302dd9 100644 --- a/public/jsonld/metamodel/LiteralInteger.jsonld +++ b/public/jsonld/metamodel/LiteralInteger.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "value": {"@type": "xsd:integer"} diff --git a/public/jsonld/metamodel/LiteralRational.jsonld b/public/jsonld/metamodel/LiteralRational.jsonld index 1b300d17..819915dc 100644 --- a/public/jsonld/metamodel/LiteralRational.jsonld +++ b/public/jsonld/metamodel/LiteralRational.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "value": {"@type": "xsd:decimal"} diff --git a/public/jsonld/metamodel/LiteralString.jsonld b/public/jsonld/metamodel/LiteralString.jsonld index 9bad2ad8..f73ad1e3 100644 --- a/public/jsonld/metamodel/LiteralString.jsonld +++ b/public/jsonld/metamodel/LiteralString.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "value": {"@type": "xsd:string"} diff --git a/public/jsonld/metamodel/LoopActionUsage.jsonld b/public/jsonld/metamodel/LoopActionUsage.jsonld index 9a3b3717..05d16186 100644 --- a/public/jsonld/metamodel/LoopActionUsage.jsonld +++ b/public/jsonld/metamodel/LoopActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "bodyAction": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -16,13 +16,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -103,6 +102,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Membership.jsonld b/public/jsonld/metamodel/Membership.jsonld index 22afc23f..4af2d05f 100644 --- a/public/jsonld/metamodel/Membership.jsonld +++ b/public/jsonld/metamodel/Membership.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, - "ownedMemberElement": {"@type": "@id"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -27,6 +26,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/MergeNode.jsonld b/public/jsonld/metamodel/MergeNode.jsonld index 53acf605..990fe08b 100644 --- a/public/jsonld/metamodel/MergeNode.jsonld +++ b/public/jsonld/metamodel/MergeNode.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Metaclass.jsonld b/public/jsonld/metamodel/Metaclass.jsonld index 5bb0080b..15b23fce 100644 --- a/public/jsonld/metamodel/Metaclass.jsonld +++ b/public/jsonld/metamodel/Metaclass.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -44,6 +43,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/MetadataDefinition.jsonld b/public/jsonld/metamodel/MetadataDefinition.jsonld index 0118d9e4..5d27479a 100644 --- a/public/jsonld/metamodel/MetadataDefinition.jsonld +++ b/public/jsonld/metamodel/MetadataDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -74,6 +73,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/MetadataFeature.jsonld b/public/jsonld/metamodel/MetadataFeature.jsonld index 34b3a5f7..330eb26b 100644 --- a/public/jsonld/metamodel/MetadataFeature.jsonld +++ b/public/jsonld/metamodel/MetadataFeature.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotation": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -65,6 +64,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/MetadataUsage.jsonld b/public/jsonld/metamodel/MetadataUsage.jsonld index baac5a64..53304106 100644 --- a/public/jsonld/metamodel/MetadataUsage.jsonld +++ b/public/jsonld/metamodel/MetadataUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotation": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -104,6 +103,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Multiplicity.jsonld b/public/jsonld/metamodel/Multiplicity.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/Multiplicity.jsonld +++ b/public/jsonld/metamodel/Multiplicity.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/MultiplicityRange.jsonld b/public/jsonld/metamodel/MultiplicityRange.jsonld index 2c61d501..32925356 100644 --- a/public/jsonld/metamodel/MultiplicityRange.jsonld +++ b/public/jsonld/metamodel/MultiplicityRange.jsonld @@ -5,20 +5,19 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "bound": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -64,6 +63,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "upperBound": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Namespace.jsonld b/public/jsonld/metamodel/Namespace.jsonld index 485ffb51..b81c0e1a 100644 --- a/public/jsonld/metamodel/Namespace.jsonld +++ b/public/jsonld/metamodel/Namespace.jsonld @@ -5,11 +5,10 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "member": {"@type": "@id"}, "membership": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/NullExpression.jsonld b/public/jsonld/metamodel/NullExpression.jsonld index 98895b32..12567047 100644 --- a/public/jsonld/metamodel/NullExpression.jsonld +++ b/public/jsonld/metamodel/NullExpression.jsonld @@ -5,21 +5,20 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -67,6 +66,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/ObjectiveMembership.jsonld b/public/jsonld/metamodel/ObjectiveMembership.jsonld index b84a0a98..03a784b0 100644 --- a/public/jsonld/metamodel/ObjectiveMembership.jsonld +++ b/public/jsonld/metamodel/ObjectiveMembership.jsonld @@ -5,23 +5,25 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedObjectiveRequirement": {"@type": "@id"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, @@ -34,6 +36,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/OccurrenceDefinition.jsonld b/public/jsonld/metamodel/OccurrenceDefinition.jsonld index 0118d9e4..5d27479a 100644 --- a/public/jsonld/metamodel/OccurrenceDefinition.jsonld +++ b/public/jsonld/metamodel/OccurrenceDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -74,6 +73,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/OccurrenceUsage.jsonld b/public/jsonld/metamodel/OccurrenceUsage.jsonld index 9fbe5488..65def3ee 100644 --- a/public/jsonld/metamodel/OccurrenceUsage.jsonld +++ b/public/jsonld/metamodel/OccurrenceUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -99,6 +98,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/OperatorExpression.jsonld b/public/jsonld/metamodel/OperatorExpression.jsonld index 1701f8f3..40796f6e 100644 --- a/public/jsonld/metamodel/OperatorExpression.jsonld +++ b/public/jsonld/metamodel/OperatorExpression.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "argument": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -70,6 +69,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/OwningMembership.jsonld b/public/jsonld/metamodel/OwningMembership.jsonld new file mode 100644 index 00000000..67929fe3 --- /dev/null +++ b/public/jsonld/metamodel/OwningMembership.jsonld @@ -0,0 +1,40 @@ +{ + "@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#", + + "aliasIds": {"@type": "xsd:string"}, + "documentation": {"@type": "@id"}, + "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, + "memberElement": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, + "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, + "membershipOwningNamespace": {"@type": "@id"}, + "name": {"@type": "xsd:string"}, + "ownedAnnotation": {"@type": "@id"}, + "ownedElement": {"@type": "@id"}, + "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, + "ownedRelatedElement": {"@type": "@id"}, + "ownedRelationship": {"@type": "@id"}, + "owner": {"@type": "@id"}, + "owningMembership": {"@type": "@id"}, + "owningNamespace": {"@type": "@id"}, + "owningRelatedElement": {"@type": "@id"}, + "owningRelationship": {"@type": "@id"}, + "qualifiedName": {"@type": "xsd:string"}, + "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, + "source": {"@type": "@id"}, + "target": {"@type": "@id"}, + "textualRepresentation": {"@type": "@id"}, + "visibility": {"@type": "@vocab"} + + } +} \ No newline at end of file diff --git a/public/jsonld/metamodel/Package.jsonld b/public/jsonld/metamodel/Package.jsonld index dbb99ee0..8109db16 100644 --- a/public/jsonld/metamodel/Package.jsonld +++ b/public/jsonld/metamodel/Package.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "filterCondition": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "member": {"@type": "@id"}, "membership": {"@type": "@id"}, @@ -26,6 +25,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/ParameterMembership.jsonld b/public/jsonld/metamodel/ParameterMembership.jsonld index cc166e60..0ae70241 100644 --- a/public/jsonld/metamodel/ParameterMembership.jsonld +++ b/public/jsonld/metamodel/ParameterMembership.jsonld @@ -5,25 +5,26 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, - "memberParameter": {"@type": "@id"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, "ownedMemberParameter": {"@type": "@id"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -35,6 +36,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/PartDefinition.jsonld b/public/jsonld/metamodel/PartDefinition.jsonld index 0118d9e4..5d27479a 100644 --- a/public/jsonld/metamodel/PartDefinition.jsonld +++ b/public/jsonld/metamodel/PartDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -74,6 +73,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/PartUsage.jsonld b/public/jsonld/metamodel/PartUsage.jsonld index 899d5c66..bfe8930f 100644 --- a/public/jsonld/metamodel/PartUsage.jsonld +++ b/public/jsonld/metamodel/PartUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -101,6 +100,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/PerformActionUsage.jsonld b/public/jsonld/metamodel/PerformActionUsage.jsonld index 7afc7a6d..9c90aabd 100644 --- a/public/jsonld/metamodel/PerformActionUsage.jsonld +++ b/public/jsonld/metamodel/PerformActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,14 +15,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "eventOccurrence": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -104,6 +103,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/PortConjugation.jsonld b/public/jsonld/metamodel/PortConjugation.jsonld index e3651388..60acfc86 100644 --- a/public/jsonld/metamodel/PortConjugation.jsonld +++ b/public/jsonld/metamodel/PortConjugation.jsonld @@ -5,13 +5,12 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "conjugatedPortDefinition": {"@type": "@id"}, "conjugatedType": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "originalPortDefinition": {"@type": "@id"}, "originalType": {"@type": "@id"}, @@ -27,6 +26,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/PortDefinition.jsonld b/public/jsonld/metamodel/PortDefinition.jsonld index a37a16ef..2461a4ff 100644 --- a/public/jsonld/metamodel/PortDefinition.jsonld +++ b/public/jsonld/metamodel/PortDefinition.jsonld @@ -5,17 +5,16 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "conjugatedPortDefinition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -75,6 +74,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/PortUsage.jsonld b/public/jsonld/metamodel/PortUsage.jsonld index 1a4a671e..fadf7a52 100644 --- a/public/jsonld/metamodel/PortUsage.jsonld +++ b/public/jsonld/metamodel/PortUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -97,10 +96,10 @@ "owningType": {"@type": "@id"}, "owningUsage": {"@type": "@id"}, "portDefinition": {"@type": "@id"}, - "portOwningUsage": {"@type": "@id"}, "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/PortioningFeature.jsonld b/public/jsonld/metamodel/PortioningFeature.jsonld index 3f183bed..e2d88091 100644 --- a/public/jsonld/metamodel/PortioningFeature.jsonld +++ b/public/jsonld/metamodel/PortioningFeature.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -63,6 +62,7 @@ "owningType": {"@type": "@id"}, "portionKind": {"@type": "@vocab"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Predicate.jsonld b/public/jsonld/metamodel/Predicate.jsonld index 0b9795cb..4066e511 100644 --- a/public/jsonld/metamodel/Predicate.jsonld +++ b/public/jsonld/metamodel/Predicate.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -48,6 +47,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Redefinition.jsonld b/public/jsonld/metamodel/Redefinition.jsonld index 27b7e64e..25d94d66 100644 --- a/public/jsonld/metamodel/Redefinition.jsonld +++ b/public/jsonld/metamodel/Redefinition.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "general": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -27,6 +26,7 @@ "redefinedFeature": {"@type": "@id"}, "redefiningFeature": {"@type": "@id"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "specific": {"@type": "@id"}, "subsettedFeature": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ReferenceUsage.jsonld b/public/jsonld/metamodel/ReferenceUsage.jsonld index 5ec14453..a78e54ac 100644 --- a/public/jsonld/metamodel/ReferenceUsage.jsonld +++ b/public/jsonld/metamodel/ReferenceUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -94,6 +93,7 @@ "owningType": {"@type": "@id"}, "owningUsage": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Relationship.jsonld b/public/jsonld/metamodel/Relationship.jsonld index 51b18c0a..82df44df 100644 --- a/public/jsonld/metamodel/Relationship.jsonld +++ b/public/jsonld/metamodel/Relationship.jsonld @@ -5,11 +5,10 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -22,6 +21,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/RenderingDefinition.jsonld b/public/jsonld/metamodel/RenderingDefinition.jsonld index 457ded2e..c4bdd37d 100644 --- a/public/jsonld/metamodel/RenderingDefinition.jsonld +++ b/public/jsonld/metamodel/RenderingDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -75,6 +74,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "rendering": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/RenderingUsage.jsonld b/public/jsonld/metamodel/RenderingUsage.jsonld index 181b5cd1..52e5e4b4 100644 --- a/public/jsonld/metamodel/RenderingUsage.jsonld +++ b/public/jsonld/metamodel/RenderingUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -102,6 +101,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "renderingDefinition": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/RequirementConstraintMembership.jsonld b/public/jsonld/metamodel/RequirementConstraintMembership.jsonld index 08c5d241..75cc750b 100644 --- a/public/jsonld/metamodel/RequirementConstraintMembership.jsonld +++ b/public/jsonld/metamodel/RequirementConstraintMembership.jsonld @@ -5,25 +5,27 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "kind": {"@type": "@vocab"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedConstraint": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -36,6 +38,7 @@ "qualifiedName": {"@type": "xsd:string"}, "referencedConstraint": {"@type": "@id"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/RequirementDefinition.jsonld b/public/jsonld/metamodel/RequirementDefinition.jsonld index dc84a8b8..d8ea0ff7 100644 --- a/public/jsonld/metamodel/RequirementDefinition.jsonld +++ b/public/jsonld/metamodel/RequirementDefinition.jsonld @@ -6,19 +6,18 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assumedConstraint": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -83,6 +82,7 @@ "reqId": {"@type": "xsd:string"}, "requiredConstraint": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/RequirementUsage.jsonld b/public/jsonld/metamodel/RequirementUsage.jsonld index e0b2e0f6..ee8f3563 100644 --- a/public/jsonld/metamodel/RequirementUsage.jsonld +++ b/public/jsonld/metamodel/RequirementUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assumedConstraint": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -17,6 +17,7 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, @@ -24,8 +25,6 @@ "featuringType": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, "function": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -112,6 +111,7 @@ "requiredConstraint": {"@type": "@id"}, "requirementDefinition": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "text": {"@type": "xsd:string"}, diff --git a/public/jsonld/metamodel/RequirementVerificationMembership.jsonld b/public/jsonld/metamodel/RequirementVerificationMembership.jsonld index 72aa4d76..37c1ee89 100644 --- a/public/jsonld/metamodel/RequirementVerificationMembership.jsonld +++ b/public/jsonld/metamodel/RequirementVerificationMembership.jsonld @@ -5,25 +5,27 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "kind": {"@type": "@vocab"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedConstraint": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "ownedRequirement": {"@type": "@id"}, @@ -37,6 +39,7 @@ "qualifiedName": {"@type": "xsd:string"}, "referencedConstraint": {"@type": "@id"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ResultExpressionMembership.jsonld b/public/jsonld/metamodel/ResultExpressionMembership.jsonld index e0372c7c..8edc7195 100644 --- a/public/jsonld/metamodel/ResultExpressionMembership.jsonld +++ b/public/jsonld/metamodel/ResultExpressionMembership.jsonld @@ -5,23 +5,25 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "ownedResultExpression": {"@type": "@id"}, @@ -34,6 +36,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ReturnParameterMembership.jsonld b/public/jsonld/metamodel/ReturnParameterMembership.jsonld index cc166e60..0ae70241 100644 --- a/public/jsonld/metamodel/ReturnParameterMembership.jsonld +++ b/public/jsonld/metamodel/ReturnParameterMembership.jsonld @@ -5,25 +5,26 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, - "memberParameter": {"@type": "@id"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, "ownedMemberParameter": {"@type": "@id"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -35,6 +36,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/SatisfyRequirementUsage.jsonld b/public/jsonld/metamodel/SatisfyRequirementUsage.jsonld index 96cda332..bfb6f3b5 100644 --- a/public/jsonld/metamodel/SatisfyRequirementUsage.jsonld +++ b/public/jsonld/metamodel/SatisfyRequirementUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assertedConstraint": {"@type": "@id"}, "assumedConstraint": {"@type": "@id"}, "behavior": {"@type": "@id"}, @@ -18,6 +18,7 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, @@ -25,8 +26,6 @@ "featuringType": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, "function": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -116,6 +115,7 @@ "result": {"@type": "@id"}, "satisfiedRequirement": {"@type": "@id"}, "satisfyingFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "text": {"@type": "xsd:string"}, diff --git a/public/jsonld/metamodel/SelectExpression.jsonld b/public/jsonld/metamodel/SelectExpression.jsonld index 1701f8f3..40796f6e 100644 --- a/public/jsonld/metamodel/SelectExpression.jsonld +++ b/public/jsonld/metamodel/SelectExpression.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "argument": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -70,6 +69,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/SendActionUsage.jsonld b/public/jsonld/metamodel/SendActionUsage.jsonld index 2c9559a7..6862a70f 100644 --- a/public/jsonld/metamodel/SendActionUsage.jsonld +++ b/public/jsonld/metamodel/SendActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -15,13 +15,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -104,6 +103,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "receiverArgument": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/SourceEnd.jsonld b/public/jsonld/metamodel/SourceEnd.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/SourceEnd.jsonld +++ b/public/jsonld/metamodel/SourceEnd.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Specialization.jsonld b/public/jsonld/metamodel/Specialization.jsonld index 518d8770..e7e847cc 100644 --- a/public/jsonld/metamodel/Specialization.jsonld +++ b/public/jsonld/metamodel/Specialization.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "general": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -24,6 +23,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "specific": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/StakeholderMembership.jsonld b/public/jsonld/metamodel/StakeholderMembership.jsonld index 907989f5..5732be7f 100644 --- a/public/jsonld/metamodel/StakeholderMembership.jsonld +++ b/public/jsonld/metamodel/StakeholderMembership.jsonld @@ -5,25 +5,26 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, - "memberParameter": {"@type": "@id"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, "ownedMemberParameter": {"@type": "@id"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "ownedStakeholderParameter": {"@type": "@id"}, @@ -36,6 +37,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/StateDefinition.jsonld b/public/jsonld/metamodel/StateDefinition.jsonld index 21f26c4f..bfed6486 100644 --- a/public/jsonld/metamodel/StateDefinition.jsonld +++ b/public/jsonld/metamodel/StateDefinition.jsonld @@ -6,19 +6,18 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "action": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "doAction": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "entryAction": {"@type": "@id"}, "exitAction": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -80,6 +79,7 @@ "owningRelationship": {"@type": "@id"}, "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "state": {"@type": "@id"}, "step": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/StateSubactionMembership.jsonld b/public/jsonld/metamodel/StateSubactionMembership.jsonld index 38f3d684..5df54403 100644 --- a/public/jsonld/metamodel/StateSubactionMembership.jsonld +++ b/public/jsonld/metamodel/StateSubactionMembership.jsonld @@ -6,24 +6,26 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "action": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "kind": {"@type": "@vocab"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -35,6 +37,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/StateUsage.jsonld b/public/jsonld/metamodel/StateUsage.jsonld index cf81d04b..6aa3b5c3 100644 --- a/public/jsonld/metamodel/StateUsage.jsonld +++ b/public/jsonld/metamodel/StateUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -16,6 +16,7 @@ "doAction": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "entryAction": {"@type": "@id"}, @@ -23,8 +24,6 @@ "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -106,6 +105,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "stateDefinition": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Step.jsonld b/public/jsonld/metamodel/Step.jsonld index 53c1ca2d..6cb7f450 100644 --- a/public/jsonld/metamodel/Step.jsonld +++ b/public/jsonld/metamodel/Step.jsonld @@ -5,20 +5,19 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -64,6 +63,7 @@ "owningType": {"@type": "@id"}, "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Structure.jsonld b/public/jsonld/metamodel/Structure.jsonld index 5bb0080b..15b23fce 100644 --- a/public/jsonld/metamodel/Structure.jsonld +++ b/public/jsonld/metamodel/Structure.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -44,6 +43,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/Subclassification.jsonld b/public/jsonld/metamodel/Subclassification.jsonld index 2d31da6b..47889fe3 100644 --- a/public/jsonld/metamodel/Subclassification.jsonld +++ b/public/jsonld/metamodel/Subclassification.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "general": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "specific": {"@type": "@id"}, "subclassifier": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/SubjectMembership.jsonld b/public/jsonld/metamodel/SubjectMembership.jsonld index 784e27ae..091bf672 100644 --- a/public/jsonld/metamodel/SubjectMembership.jsonld +++ b/public/jsonld/metamodel/SubjectMembership.jsonld @@ -5,25 +5,26 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, - "memberParameter": {"@type": "@id"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, "ownedMemberParameter": {"@type": "@id"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "ownedSubjectParameter": {"@type": "@id"}, @@ -36,6 +37,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Subsetting.jsonld b/public/jsonld/metamodel/Subsetting.jsonld index f0ebcf3a..0675f168 100644 --- a/public/jsonld/metamodel/Subsetting.jsonld +++ b/public/jsonld/metamodel/Subsetting.jsonld @@ -5,12 +5,11 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "general": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "specific": {"@type": "@id"}, "subsettedFeature": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/Succession.jsonld b/public/jsonld/metamodel/Succession.jsonld index bdd21e87..b3057f2c 100644 --- a/public/jsonld/metamodel/Succession.jsonld +++ b/public/jsonld/metamodel/Succession.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectorEnd": {"@type": "@id"}, @@ -14,14 +14,13 @@ "documentation": {"@type": "@id"}, "effectStep": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, "guardExpression": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -71,6 +70,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/SuccessionAsUsage.jsonld b/public/jsonld/metamodel/SuccessionAsUsage.jsonld index 3978cecb..b5175f1e 100644 --- a/public/jsonld/metamodel/SuccessionAsUsage.jsonld +++ b/public/jsonld/metamodel/SuccessionAsUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "connectorEnd": {"@type": "@id"}, @@ -16,14 +16,13 @@ "documentation": {"@type": "@id"}, "effectStep": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, "guardExpression": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -103,6 +102,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/SuccessionFlowConnectionUsage.jsonld b/public/jsonld/metamodel/SuccessionFlowConnectionUsage.jsonld index ba9add6e..359dfdac 100644 --- a/public/jsonld/metamodel/SuccessionFlowConnectionUsage.jsonld +++ b/public/jsonld/metamodel/SuccessionFlowConnectionUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -18,14 +18,13 @@ "documentation": {"@type": "@id"}, "effectStep": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, "guardExpression": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -117,6 +116,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "sourceOutputFeature": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/SuccessionItemFlow.jsonld b/public/jsonld/metamodel/SuccessionItemFlow.jsonld index 4b3126e0..70010df8 100644 --- a/public/jsonld/metamodel/SuccessionItemFlow.jsonld +++ b/public/jsonld/metamodel/SuccessionItemFlow.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "association": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -15,14 +15,13 @@ "documentation": {"@type": "@id"}, "effectStep": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, "guardExpression": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -77,6 +76,7 @@ "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, "relatedFeature": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "sourceFeature": {"@type": "@id"}, "sourceOutputFeature": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/TargetEnd.jsonld b/public/jsonld/metamodel/TargetEnd.jsonld index 00b34b84..80ad3f21 100644 --- a/public/jsonld/metamodel/TargetEnd.jsonld +++ b/public/jsonld/metamodel/TargetEnd.jsonld @@ -5,19 +5,18 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -62,6 +61,7 @@ "owningRelationship": {"@type": "@id"}, "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/TextualRepresentation.jsonld b/public/jsonld/metamodel/TextualRepresentation.jsonld index 025da3b9..eadfde79 100644 --- a/public/jsonld/metamodel/TextualRepresentation.jsonld +++ b/public/jsonld/metamodel/TextualRepresentation.jsonld @@ -5,14 +5,13 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "annotatedElement": {"@type": "@id"}, "annotation": {"@type": "@id"}, "body": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "language": {"@type": "xsd:string"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, @@ -24,6 +23,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "representedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/TransitionFeatureMembership.jsonld b/public/jsonld/metamodel/TransitionFeatureMembership.jsonld index 8e8c1e92..599cf033 100644 --- a/public/jsonld/metamodel/TransitionFeatureMembership.jsonld +++ b/public/jsonld/metamodel/TransitionFeatureMembership.jsonld @@ -5,24 +5,26 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "kind": {"@type": "@vocab"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "owner": {"@type": "@id"}, @@ -34,6 +36,7 @@ "owningType": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/TransitionUsage.jsonld b/public/jsonld/metamodel/TransitionUsage.jsonld index 8a4a2f4f..77d886af 100644 --- a/public/jsonld/metamodel/TransitionUsage.jsonld +++ b/public/jsonld/metamodel/TransitionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, @@ -16,14 +16,13 @@ "documentation": {"@type": "@id"}, "effectAction": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, "guardExpression": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -104,6 +103,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "succession": {"@type": "@id"}, "target": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/TriggerInvocationExpression.jsonld b/public/jsonld/metamodel/TriggerInvocationExpression.jsonld index 8bc2bc30..8c9c746c 100644 --- a/public/jsonld/metamodel/TriggerInvocationExpression.jsonld +++ b/public/jsonld/metamodel/TriggerInvocationExpression.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "argument": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, @@ -69,6 +68,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Type.jsonld b/public/jsonld/metamodel/Type.jsonld index dfe7e663..f1a1aef4 100644 --- a/public/jsonld/metamodel/Type.jsonld +++ b/public/jsonld/metamodel/Type.jsonld @@ -5,15 +5,14 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -43,6 +42,7 @@ "owningNamespace": {"@type": "@id"}, "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"} } diff --git a/public/jsonld/metamodel/TypeFeaturing.jsonld b/public/jsonld/metamodel/TypeFeaturing.jsonld index a5b37302..ceade41c 100644 --- a/public/jsonld/metamodel/TypeFeaturing.jsonld +++ b/public/jsonld/metamodel/TypeFeaturing.jsonld @@ -5,13 +5,12 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, @@ -25,6 +24,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"} diff --git a/public/jsonld/metamodel/Usage.jsonld b/public/jsonld/metamodel/Usage.jsonld index 5ec14453..a78e54ac 100644 --- a/public/jsonld/metamodel/Usage.jsonld +++ b/public/jsonld/metamodel/Usage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,13 +13,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -94,6 +93,7 @@ "owningType": {"@type": "@id"}, "owningUsage": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/UseCaseDefinition.jsonld b/public/jsonld/metamodel/UseCaseDefinition.jsonld index 3054688d..a76c951e 100644 --- a/public/jsonld/metamodel/UseCaseDefinition.jsonld +++ b/public/jsonld/metamodel/UseCaseDefinition.jsonld @@ -7,18 +7,17 @@ "action": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "calculation": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "includedUseCase": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -83,6 +82,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/UseCaseUsage.jsonld b/public/jsonld/metamodel/UseCaseUsage.jsonld index 1d92b23e..8eca0951 100644 --- a/public/jsonld/metamodel/UseCaseUsage.jsonld +++ b/public/jsonld/metamodel/UseCaseUsage.jsonld @@ -7,7 +7,7 @@ "actionDefinition": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "calculationDefinition": {"@type": "@id"}, "caseDefinition": {"@type": "@id"}, @@ -18,14 +18,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "includedUseCase": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, @@ -110,6 +109,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/VariantMembership.jsonld b/public/jsonld/metamodel/VariantMembership.jsonld index 4ed8b283..ce0b592e 100644 --- a/public/jsonld/metamodel/VariantMembership.jsonld +++ b/public/jsonld/metamodel/VariantMembership.jsonld @@ -5,19 +5,22 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, + "elementId": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "ownedVariantUsage": {"@type": "@id"}, @@ -28,6 +31,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/VerificationCaseDefinition.jsonld b/public/jsonld/metamodel/VerificationCaseDefinition.jsonld index a90d1179..0e5bee0a 100644 --- a/public/jsonld/metamodel/VerificationCaseDefinition.jsonld +++ b/public/jsonld/metamodel/VerificationCaseDefinition.jsonld @@ -7,18 +7,17 @@ "action": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "calculation": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -82,6 +81,7 @@ "parameter": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/VerificationCaseUsage.jsonld b/public/jsonld/metamodel/VerificationCaseUsage.jsonld index f0287a3d..0d9f2b9b 100644 --- a/public/jsonld/metamodel/VerificationCaseUsage.jsonld +++ b/public/jsonld/metamodel/VerificationCaseUsage.jsonld @@ -7,7 +7,7 @@ "actionDefinition": {"@type": "@id"}, "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "calculationDefinition": {"@type": "@id"}, "caseDefinition": {"@type": "@id"}, @@ -18,14 +18,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "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"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -109,6 +108,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "subjectParameter": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ViewDefinition.jsonld b/public/jsonld/metamodel/ViewDefinition.jsonld index 11fb1bfb..e3024b1e 100644 --- a/public/jsonld/metamodel/ViewDefinition.jsonld +++ b/public/jsonld/metamodel/ViewDefinition.jsonld @@ -5,16 +5,15 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -75,6 +74,7 @@ "owningRelationship": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "satisfiedViewpoint": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "usage": {"@type": "@id"}, "variant": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ViewRenderingMembership.jsonld b/public/jsonld/metamodel/ViewRenderingMembership.jsonld index 05be9e4a..93891d88 100644 --- a/public/jsonld/metamodel/ViewRenderingMembership.jsonld +++ b/public/jsonld/metamodel/ViewRenderingMembership.jsonld @@ -5,23 +5,25 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "documentation": {"@type": "@id"}, - "effectiveMemberName": {"@type": "xsd:string"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "featureOfType": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "memberElement": {"@type": "@id"}, - "memberFeature": {"@type": "@id"}, + "memberElementId": {"@type": "xsd:string"}, "memberName": {"@type": "xsd:string"}, + "memberShortName": {"@type": "xsd:string"}, "membershipOwningNamespace": {"@type": "@id"}, "name": {"@type": "xsd:string"}, "ownedAnnotation": {"@type": "@id"}, "ownedElement": {"@type": "@id"}, "ownedMemberElement": {"@type": "@id"}, + "ownedMemberElementId": {"@type": "xsd:string"}, "ownedMemberFeature": {"@type": "@id"}, + "ownedMemberName": {"@type": "xsd:string"}, + "ownedMemberShortName": {"@type": "xsd:string"}, "ownedRelatedElement": {"@type": "@id"}, "ownedRelationship": {"@type": "@id"}, "ownedRendering": {"@type": "@id"}, @@ -35,6 +37,7 @@ "qualifiedName": {"@type": "xsd:string"}, "referencedRendering": {"@type": "@id"}, "relatedElement": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "source": {"@type": "@id"}, "target": {"@type": "@id"}, "textualRepresentation": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ViewUsage.jsonld b/public/jsonld/metamodel/ViewUsage.jsonld index 2abc066c..bc11f5c3 100644 --- a/public/jsonld/metamodel/ViewUsage.jsonld +++ b/public/jsonld/metamodel/ViewUsage.jsonld @@ -5,7 +5,7 @@ "dcterms": "http://purl.org/dc/terms/", "xsd": "http://www.w3.org/2001/XMLSchema#", - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "chainingFeature": {"@type": "@id"}, "definition": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, @@ -13,14 +13,13 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "exposedNamespace": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -103,6 +102,7 @@ "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, "satisfiedViewpoint": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "usage": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ViewpointDefinition.jsonld b/public/jsonld/metamodel/ViewpointDefinition.jsonld index 76640872..5f99526a 100644 --- a/public/jsonld/metamodel/ViewpointDefinition.jsonld +++ b/public/jsonld/metamodel/ViewpointDefinition.jsonld @@ -6,19 +6,18 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assumedConstraint": {"@type": "@id"}, "directedFeature": {"@type": "@id"}, "directedUsage": {"@type": "@id"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "expression": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, "inheritedMembership": {"@type": "@id"}, @@ -83,6 +82,7 @@ "reqId": {"@type": "xsd:string"}, "requiredConstraint": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "step": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, diff --git a/public/jsonld/metamodel/ViewpointUsage.jsonld b/public/jsonld/metamodel/ViewpointUsage.jsonld index 9cdee517..517ad73c 100644 --- a/public/jsonld/metamodel/ViewpointUsage.jsonld +++ b/public/jsonld/metamodel/ViewpointUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actorParameter": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "assumedConstraint": {"@type": "@id"}, "behavior": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -17,6 +17,7 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, @@ -24,8 +25,6 @@ "featuringType": {"@type": "@id"}, "framedConcern": {"@type": "@id"}, "function": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -112,6 +111,7 @@ "requiredConstraint": {"@type": "@id"}, "requirementDefinition": {"@type": "@id"}, "result": {"@type": "@id"}, + "shortName": {"@type": "xsd:string"}, "stakeholderParameter": {"@type": "@id"}, "subjectParameter": {"@type": "@id"}, "text": {"@type": "xsd:string"}, diff --git a/public/jsonld/metamodel/WhileLoopActionUsage.jsonld b/public/jsonld/metamodel/WhileLoopActionUsage.jsonld index 92ae4188..3e2717cf 100644 --- a/public/jsonld/metamodel/WhileLoopActionUsage.jsonld +++ b/public/jsonld/metamodel/WhileLoopActionUsage.jsonld @@ -6,7 +6,7 @@ "xsd": "http://www.w3.org/2001/XMLSchema#", "actionDefinition": {"@type": "@id"}, - "aliasId": {"@type": "xsd:string"}, + "aliasIds": {"@type": "xsd:string"}, "behavior": {"@type": "@id"}, "bodyAction": {"@type": "@id"}, "chainingFeature": {"@type": "@id"}, @@ -16,13 +16,12 @@ "direction": {"@type": "@vocab"}, "documentation": {"@type": "@id"}, "effectiveName": {"@type": "xsd:string"}, + "elementId": {"@type": "dcterms:identifier"}, "endFeature": {"@type": "@id"}, "endOwningType": {"@type": "@id"}, "feature": {"@type": "@id"}, "featureMembership": {"@type": "@id"}, "featuringType": {"@type": "@id"}, - "humanId": {"@type": "xsd:string"}, - "identifier": {"@type": "dcterms:identifier"}, "importedMembership": {"@type": "@id"}, "individualDefinition": {"@type": "@id"}, "inheritedFeature": {"@type": "@id"}, @@ -103,6 +102,7 @@ "portionKind": {"@type": "@vocab"}, "portioningFeature": {"@type": "@id"}, "qualifiedName": {"@type": "xsd:string"}, + "shortName": {"@type": "xsd:string"}, "textualRepresentation": {"@type": "@id"}, "type": {"@type": "@id"}, "untilArgument": {"@type": "@id"}, From bad14b6d01886c777ffe24826feff34849eba3b9 Mon Sep 17 00:00:00 2001 From: Ivan Gomes Date: Thu, 12 May 2022 10:43:30 -0400 Subject: [PATCH 2/2] Update version number to 2022-04-m1 --- build.sbt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build.sbt b/build.sbt index d1df3940..e3ab6af0 100644 --- a/build.sbt +++ b/build.sbt @@ -1,7 +1,7 @@ name := """SysML-v2-API-Services""" organization := "org.omg" -version := "2022-03" +version := "2022-04-m1" javacOptions ++= Seq("-source", "11", "-target", "11", "-Xlint")