C++ (Cpp) declareFctの例

コード例 #1

ファイル: UmlTransition.cpp プロジェクト: bleakxanadu/douml

void UmlTransition::init()
{
    declareFct("transition", "uml:Transition", &importIt);
    declareFct("transition", "", &importIt);  // Borland Together 2006 for Eclipse

    Trigger::init();
}

コード例 #2

ファイル: UmlActivity.cpp プロジェクト: bleakxanadu/douml

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

コード例 #3

void UmlAttribute::init()
{
  declareFct("ownedattribute", "uml:Property", &importIt);
  declareFct("ownedattribute", "", &importIt);	// Eclipse .uml
  declareFct("ownedliteral", "uml:EnumerationLiteral", &importIt);
  declareFct("ownedliteral", "", &importIt);	// eclipse
}

コード例 #4

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlOpaqueAction::init()
{
    declareFct("node", "uml:OpaqueAction", &importIt);
    declareFct("containednode", "uml:OpaqueAction", &importIt);

    declareFct("node", "uml:Action", &importIt);
    declareFct("containednode", "uml:Action", &importIt);
}

コード例 #5

ファイル: UmlNode.cpp プロジェクト: ErickCastellanos/douml

void UmlNode::init()
{
    declareFct("ownedmember", "uml:Node", &importIt);
    declareFct("packagedelement", "uml:Node", &importIt);
    declareFct("ownedmember", "uml:Device", &importIt);
    declareFct("packagedelement", "uml:Device", &importIt);

}

コード例 #6

ファイル: UmlState.cpp プロジェクト: SciBoy/douml

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

コード例 #7

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

コード例 #8

ファイル: UmlUseCase.cpp プロジェクト: SciBoy/douml

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

}

コード例 #9

ファイル: UmlActivityObject.cpp プロジェクト: ErickCastellanos/douml

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

コード例 #10

ファイル: UmlActivityPin.cpp プロジェクト: SciBoy/douml

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

}

コード例 #11

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlBroadcastSignalAction::init()
{
    declareFct("node", "uml:BroadcastSignalAction", &importIt);
    declareFct("containednode", "uml:BroadcastSignalAction", &importIt);
}

コード例 #12

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlReduceAction::init()
{
    declareFct("node", "uml:ReduceAction", &importIt);
    declareFct("containednode", "uml:ReduceAction", &importIt);
}

コード例 #13

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlRaiseExceptionAction::init()
{
    declareFct("node", "uml:RaiseExceptionAction", &importIt);
    declareFct("containednode", "uml:RaiseExceptionAction", &importIt);
}

コード例 #14

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlTestIdentityAction::init()
{
    declareFct("node", "uml:TestIdentityAction", &importIt);
    declareFct("containednode", "uml:TestIdentityAction", &importIt);
}

コード例 #15

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlDestroyObjectAction::init()
{
    declareFct("node", "uml:DestroyObjectAction", &importIt);
    declareFct("containednode", "uml:DestroyObjectAction", &importIt);
}

コード例 #16

void UmlInterruptibleActivityRegion::init()
{
  declareFct("group", "uml:InterruptibleActivityRegion", &importIt);

}

コード例 #17

ファイル: UmlArtifact.cpp プロジェクト: bleakxanadu/douml

void UmlArtifact::init()
{
    declareFct("ownedmember", "uml:Artifact", &importIt);
    declareFct("packagedelement", "uml:Artifact", &importIt);
}

コード例 #18

void UmlFinalState::init()
{
  declareFct("subvertex", "uml:FinalState", &importIt);

}

コード例 #19

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlUnmarshallAction::init()
{
    declareFct("node", "uml:UnmarshallAction", &importIt);
    declareFct("containednode", "uml:UnmarshallAction", &importIt);
}

コード例 #20

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlCallBehaviorAction::init()
{
    declareFct("node", "uml:CallBehaviorAction", &importIt);
    declareFct("containednode", "uml:CallBehaviorAction", &importIt);
}

コード例 #21

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlCallOperationAction::init()
{
    declareFct("node", "uml:CallOperationAction", &importIt);
    declareFct("containednode", "uml:CallOperationAction", &importIt);
}

コード例 #22

ファイル: UmlRegion.cpp プロジェクト: ErickCastellanos/douml

void UmlRegion::init()
{
    declareFct("region", "uml:Region", &importIt);
    declareFct("region", "", &importIt);	// sometimes with Visual Paradigm
}

コード例 #23

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlRemoveVariableValueAction::init()
{
    declareFct("node", "uml:RemoveVariableValueAction", &importIt);
    declareFct("containednode", "uml:RemoveVariableValueAction", &importIt);
}

コード例 #24

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlValueSpecificationAction::init()
{
    declareFct("node", "uml:ValueSpecificationAction", &importIt);
    declareFct("containednode", "uml:ValueSpecificationAction", &importIt);
}

コード例 #25

ファイル: UmlItem.cpp プロジェクト: daniel7solis/douml

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

}

コード例 #26

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlAcceptCallAction::init()
{
    declareFct("node", "uml:AcceptCallAction", &importIt);
    declareFct("containednode", "uml:AcceptCallAction", &importIt);
}

コード例 #27

ファイル: UmlPackage.cpp プロジェクト: bleakxanadu/douml

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

コード例 #28

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlSendSignalAction::init()
{
    declareFct("node", "uml:SendSignalAction", &importIt);
    declareFct("containednode", "uml:SendSignalAction", &importIt);
}

コード例 #29

ファイル: UmlClass.cpp プロジェクト: daniel7solis/douml

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

コード例 #30

ファイル: UmlActivityActionClasses.cpp プロジェクト: ErickCastellanos/douml

void UmlCreateObjectAction::init()
{
    declareFct("node", "uml:CreateObjectAction", &importIt);
    declareFct("containednode", "uml:CreateObjectAction", &importIt);
}