void UmlTransition::init()
{
declareFct("transition", "uml:Transition", &importIt);
declareFct("transition", "", &importIt); // Borland Together 2006 for Eclipse
Trigger::init();
}
void UmlActivity::init()
{
declareFct("ownedmember", "uml:Activity", &importIt);
declareFct("packagedelement", "uml:Activity", &importIt);
UmlExpansionRegion::init();
UmlInterruptibleActivityRegion::init();
UmlActivityPartition::init();
UmlOpaqueAction::init();
UmlAcceptEventAction::init();
UmlReadVariableValueAction::init();
UmlClearVariableValueAction::init();
UmlWriteVariableValueAction::init();
UmlAddVariableValueAction::init();
UmlRemoveVariableValueAction::init();
UmlCallBehaviorAction::init();
UmlCallOperationAction::init();
UmlSendObjectAction::init();
UmlSendSignalAction::init();
UmlBroadcastSignalAction::init();
UmlUnmarshallAction::init();
UmlValueSpecificationAction::init();
UmlAcceptCallAction::init();
UmlReplyAction::init();
UmlCreateObjectAction::init();
UmlDestroyObjectAction::init();
UmlTestIdentityAction::init();
UmlRaiseExceptionAction::init();
UmlReduceAction::init();
UmlActivityControlNode::init();
UmlFlow::init();
}
void UmlAttribute::init()
{
declareFct("ownedattribute", "uml:Property", &importIt);
declareFct("ownedattribute", "", &importIt); // Eclipse .uml
declareFct("ownedliteral", "uml:EnumerationLiteral", &importIt);
declareFct("ownedliteral", "", &importIt); // eclipse
}
void UmlOpaqueAction::init()
{
declareFct("node", "uml:OpaqueAction", &importIt);
declareFct("containednode", "uml:OpaqueAction", &importIt);
declareFct("node", "uml:Action", &importIt);
declareFct("containednode", "uml:Action", &importIt);
}
void UmlNode::init()
{
declareFct("ownedmember", "uml:Node", &importIt);
declareFct("packagedelement", "uml:Node", &importIt);
declareFct("ownedmember", "uml:Device", &importIt);
declareFct("packagedelement", "uml:Device", &importIt);
}
void UmlState::init()
{
declareFct("ownedmember", "uml:StateMachine", &importIt);
declareFct("packagedelement", "uml:StateMachine", &importIt);
declareFct("subvertex", "uml:State", &importIt);
declareFct("ownedstatemachine", "", &importIt); // andromda emf
declareFct("ownedbehavior", "uml:StateMachine", &importIt); // magic draw
UmlRegion::init();
UmlPseudoState::init();
UmlFinalState::init();
UmlTransition::init();
}
void UmlFlow::init()
{
declareFct("edge", "uml:ObjectFlow", &importIt);
declareFct("containededge", "uml:ObjectFlow", &importIt);
declareFct("interruptingedge", "uml:ObjectFlow", &importIt);
declareFct("edge", "uml:ControlFlow", &importIt);
declareFct("containededge", "uml:ControlFlow", &importIt);
declareFct("interruptingedge", "uml:ControlFlow", &importIt);
}
void UmlUseCase::init()
{
declareFct("ownedmember", "uml:UseCase", &importIt);
declareFct("ownedusecase", "uml:UseCase", &importIt);
declareFct("packagedelement", "uml:UseCase", &importIt);
declareFct("extend", "uml:Extend", &importExtendInclude);
declareFct("include", "uml:Include", &importExtendInclude);
declareFct("extensionpoint", "uml:ExtensionPoint", &importExtensionPoint);
}
void UmlActivityObject::init()
{
declareFct("node", "uml:ObjectNode", &importIt);
declareFct("containednode", "uml:ObjectNode", &importIt);
declareFct("node", "uml:DataStoreNode", &importIt);
declareFct("containednode", "uml:DataStoreNode", &importIt);
declareFct("node", "uml:CentralBufferNode", &importIt);
declareFct("containednode", "uml:CentralBufferNode", &importIt);
UmlActivityPin::init();
}
void UmlActivityPin::init()
{
declareFct("argument", "uml:InputPin", &importIt);
declareFct("input", "uml:InputPin", &importIt);
declareFct("insertat", "uml:InputPin", &importIt);
declareFct("object", "uml:InputPin", &importIt);
declareFct("removeat", "uml:InputPin", &importIt);
declareFct("request", "uml:InputPin", &importIt);
declareFct("target", "uml:InputPin", &importIt);
declareFct("value", "uml:InputPin", &importIt);
declareFct("inputvalue", "uml:InputPin", &importIt);
declareFct("returninformation", "uml:InputPin", &importIt);
declareFct("first", "uml:InputPin", &importIt);
declareFct("second", "uml:InputPin", &importIt);
declareFct("exception", "uml:InputPin", &importIt);
declareFct("collection", "uml:InputPin", &importIt);
declareFct("output", "uml:OutputPin", &importIt);
declareFct("outputvalue", "uml:OutputPin", &importIt);
declareFct("result", "uml:OutputPin", &importIt);
declareFct("returninformation", "uml:OutputPin", &importIt);
}
void UmlBroadcastSignalAction::init()
{
declareFct("node", "uml:BroadcastSignalAction", &importIt);
declareFct("containednode", "uml:BroadcastSignalAction", &importIt);
}
void UmlReduceAction::init()
{
declareFct("node", "uml:ReduceAction", &importIt);
declareFct("containednode", "uml:ReduceAction", &importIt);
}
void UmlRaiseExceptionAction::init()
{
declareFct("node", "uml:RaiseExceptionAction", &importIt);
declareFct("containednode", "uml:RaiseExceptionAction", &importIt);
}
void UmlTestIdentityAction::init()
{
declareFct("node", "uml:TestIdentityAction", &importIt);
declareFct("containednode", "uml:TestIdentityAction", &importIt);
}
void UmlDestroyObjectAction::init()
{
declareFct("node", "uml:DestroyObjectAction", &importIt);
declareFct("containednode", "uml:DestroyObjectAction", &importIt);
}
void UmlInterruptibleActivityRegion::init()
{
declareFct("group", "uml:InterruptibleActivityRegion", &importIt);
}
void UmlArtifact::init()
{
declareFct("ownedmember", "uml:Artifact", &importIt);
declareFct("packagedelement", "uml:Artifact", &importIt);
}
void UmlFinalState::init()
{
declareFct("subvertex", "uml:FinalState", &importIt);
}
void UmlUnmarshallAction::init()
{
declareFct("node", "uml:UnmarshallAction", &importIt);
declareFct("containednode", "uml:UnmarshallAction", &importIt);
}
void UmlCallBehaviorAction::init()
{
declareFct("node", "uml:CallBehaviorAction", &importIt);
declareFct("containednode", "uml:CallBehaviorAction", &importIt);
}
void UmlCallOperationAction::init()
{
declareFct("node", "uml:CallOperationAction", &importIt);
declareFct("containednode", "uml:CallOperationAction", &importIt);
}
void UmlRegion::init()
{
declareFct("region", "uml:Region", &importIt);
declareFct("region", "", &importIt); // sometimes with Visual Paradigm
}
void UmlRemoveVariableValueAction::init()
{
declareFct("node", "uml:RemoveVariableValueAction", &importIt);
declareFct("containednode", "uml:RemoveVariableValueAction", &importIt);
}
void UmlValueSpecificationAction::init()
{
declareFct("node", "uml:ValueSpecificationAction", &importIt);
declareFct("containednode", "uml:ValueSpecificationAction", &importIt);
}
void UmlItem::init()
{
declareFct("xmi:documentation", "", &importDocumentation);
declareFct("ownedcomment", "uml:Comment", &importComment);
declareFct("ownedcomment", "", &importComment); // andromda emf
declareFct("xmi:extension", "", &importExtension);
declareFct("incoming", "", &incoming);
declareFct("outgoing", "", &outgoing);
declareFct("ownedbehavior", "uml:OpaqueBehavior", &importOpaqueDef);
declareFct("ownedmember", "uml:OpaqueExpression", &importOpaqueDef);
declareFct("packagedelement", "uml:OpaqueExpression", &importOpaqueDef);
declareFct("generalization", "uml:Generalization", &importGeneralization);
declareFct("generalization", "", &importGeneralization); // eclipse
declareFct("ownedelement", "uml:Dependency", &importDependency);
declareFct("ownedmember", "uml:Dependency", &importDependency);
declareFct("packagedelement", "uml:Dependency", &importDependency);
declareFct("ownedelement", "uml:Usage", &importDependency);
declareFct("ownedmember", "uml:Usage", &importDependency);
declareFct("packagedelement", "uml:Usage", &importDependency);
declareFct("ownedelement", "uml:Realization", &importRealization);
declareFct("ownedmember", "uml:Realization", &importRealization);
declareFct("packagedelement", "uml:Realization", &importRealization);
declareFct("interfacerealization", "uml:InterfaceRealization", &importRealization);
}
void UmlAcceptCallAction::init()
{
declareFct("node", "uml:AcceptCallAction", &importIt);
declareFct("containednode", "uml:AcceptCallAction", &importIt);
}
void UmlPackage::init()
{
declareFct("uml:model", "uml:Model", &importIt);
declareFct("packagedelement", "uml:Package", &importIt);
declareFct("ownedmember", "uml:Package", &importIt);
declareFct("ownedmember", "uml:Model", &importIt); // magic draw
declareFct("packagedelement", "uml:Profile", &importIt);
declareFct("ownedmember", "uml:Profile", &importIt);
declareFct("uml:package", "", &importIt);
declareFct("uml:model", "", &importIt);
declareFct("uml:profile", "", &importIt);
declareFct("profileapplication", "", &appliedProfile);
declareFct("profileapplication", "uml:ProfileApplication", &appliedProfile);
//
UmlItem::init();
UmlUseCase::init();
UmlClass::init();
UmlState::init();
UmlActivity::init();
UmlComponent::init();
UmlNode::init();
UmlArtifact::init();
}
void UmlSendSignalAction::init()
{
declareFct("node", "uml:SendSignalAction", &importIt);
declareFct("containednode", "uml:SendSignalAction", &importIt);
}
void UmlClass::init()
{
declareFct("ownedmember", "uml:Class", &importIt);
declareFct("packagedelement", "uml:Class", &importIt);
declareFct("nestedclassifier", "uml:Class", &importIt);
declareFct("ownedmember", "uml:AssociationClass", &importIt);
declareFct("packagedelement", "uml:AssociationClass", &importIt);
declareFct("nestedclassifier", "uml:AssociationClass", &importIt);
declareFct("ownedmember", "uml:Interface", &importIt);
declareFct("packagedelement", "uml:Interface", &importIt);
declareFct("nestedclassifier", "uml:Interface", &importIt);
declareFct("ownedmember", "uml:Enumeration", &importIt);
declareFct("packagedelement", "uml:Enumeration", &importIt);
declareFct("nestedclassifier", "uml:Enumeration", &importIt);
declareFct("ownedmember", "uml:Actor", &importIt);
declareFct("packagedelement", "uml:Actor", &importIt);
declareFct("nestedclassifier", "uml:Actor", &importIt);
declareFct("ownedmember", "uml:Stereotype", &importIt);
declareFct("packagedelement", "uml:Stereotype", &importIt);
//
declareFct("ownedmember", "uml:PrimitiveType", &importPrimitiveType);
declareFct("packagedelement", "uml:PrimitiveType", &importPrimitiveType);
declareFct("ownedmember", "uml:DataType", &importPrimitiveType);
declareFct("packagedelement", "uml:DataType", &importPrimitiveType);
//
UmlAttribute::init();
UmlRelation::init();
UmlOperation::init();
ClassInstance::init();
}
void UmlCreateObjectAction::init()
{
declareFct("node", "uml:CreateObjectAction", &importIt);
declareFct("containednode", "uml:CreateObjectAction", &importIt);
}
