#include "UmlCom.h"
#include "UmlBaseActivityActionClasses.h"
#include "UmlActivityActionClasses.h"
#include "UmlItem.h"
#include "UmlOperation.h"

UmlSendObjectAction * UmlBaseSendObjectAction::create(UmlItem * parent, const char * s)
{
    return (UmlSendObjectAction *) parent->create_(aSendObjectAction, s);
}

anItemKind UmlBaseSendObjectAction::kind() {
    return aSendObjectAction;
}

UmlUnmarshallAction * UmlBaseUnmarshallAction::create(UmlItem * parent, const char * s)
{
    return (UmlUnmarshallAction *) parent->create_(anUnmarshallAction, s);
}

anItemKind UmlBaseUnmarshallAction::kind() {
    return anUnmarshallAction;
}

UmlSendSignalAction * UmlBaseSendSignalAction::create(UmlItem * parent, const char * s)
{
    return (UmlSendSignalAction *) parent->create_(aSendSignalAction, s);
}

anItemKind UmlBaseSendSignalAction::kind() {
    return aSendSignalAction;
}

UmlBroadcastSignalAction * UmlBaseBroadcastSignalAction::create(UmlItem * parent, const char * s)
{
    return (UmlBroadcastSignalAction *) parent->create_(aBroadcastSignalAction, s);
}

anItemKind UmlBaseBroadcastSignalAction::kind() {
    return aBroadcastSignalAction;
}

UmlValueSpecificationAction * UmlBaseValueSpecificationAction::create(UmlItem * parent, const char * s)
{
    return (UmlValueSpecificationAction *) parent->create_(aValueSpecificationAction, s);
}

anItemKind UmlBaseValueSpecificationAction::kind() {
    return aValueSpecificationAction;
}

const QCString & UmlBaseValueSpecificationAction::value() {
    read_if_needed_();
    return _value;
}

bool UmlBaseValueSpecificationAction::set_Value(const char * v) {
    return set_it_(_value, v, setUmlActivityCmd);
}

#ifdef WITHCPP
const QCString & UmlBaseValueSpecificationAction::cppValue() {
    read_if_needed_();
    return _cpp_value;
}

bool UmlBaseValueSpecificationAction::set_CppValue(const char * v) {
    return set_it_(_cpp_value, v, setCppActivityCmd);
}
#endif

#ifdef WITHJAVA
const QCString & UmlBaseValueSpecificationAction::javaValue() {
    read_if_needed_();
    return _java_value;
}

bool UmlBaseValueSpecificationAction::set_JavaValue(const char * v) {
    return set_it_(_java_value, v, setJavaActivityCmd);
}
#endif

void UmlBaseValueSpecificationAction::unload(bool rec, bool del) {
    _value = 0;
#ifdef WITHCPP
    _cpp_value = 0;
#endif
#ifdef WITHJAVA
    _java_value = 0;
#endif
    UmlBaseActivityAction::unload(rec, del);
}

void UmlBaseValueSpecificationAction::read_uml_() {
    UmlBaseActivityAction::read_uml_();
    _value = UmlCom::read_string();
}

#ifdef WITHCPP
void UmlBaseValueSpecificationAction::read_cpp_() {
    UmlBaseActivityAction::read_cpp_();
    _cpp_value = UmlCom::read_string();
}
#endif

#ifdef WITHJAVA
void UmlBaseValueSpecificationAction::read_java_() {
    UmlBaseActivityAction::read_java_();
    _java_value = UmlCom::read_string();
}
#endif

UmlOpaqueAction * UmlBaseOpaqueAction::create(UmlItem * parent, const char * s)
{
    return (UmlOpaqueAction *) parent->create_(anOpaqueAction, s);
}

anItemKind UmlBaseOpaqueAction::kind() {
    return anOpaqueAction;
}

const QCString & UmlBaseOpaqueAction::behavior() {
    read_if_needed_();
    return _behavior;
}

bool UmlBaseOpaqueAction::set_Behavior(const char * v) {
    return set_it_(_behavior, v, setUmlActivityCmd);
}

#ifdef WITHCPP
const QCString & UmlBaseOpaqueAction::cppBehavior() {
    read_if_needed_();
    return _cpp_behavior;
}

bool UmlBaseOpaqueAction::set_CppBehavior(const char * v) {
    return set_it_(_cpp_behavior, v, setCppActivityCmd);
}
#endif

#ifdef WITHJAVA
const QCString & UmlBaseOpaqueAction::javaBehavior() {
    read_if_needed_();
    return _java_behavior;
}

bool UmlBaseOpaqueAction::set_JavaBehavior(const char * v) {
    return set_it_(_java_behavior, v, setJavaActivityCmd);
}
#endif

void UmlBaseOpaqueAction::unload(bool rec, bool del) {
    _behavior = 0;
#ifdef WITHCPP
    _cpp_behavior = 0;
#endif
#ifdef WITHJAVA
    _java_behavior = 0;
#endif
    UmlBaseActivityAction::unload(rec, del);
}

void UmlBaseOpaqueAction::read_uml_() {
    UmlBaseActivityAction::read_uml_();
    _behavior = UmlCom::read_string();
}

#ifdef WITHCPP
void UmlBaseOpaqueAction::read_cpp_() {
    UmlBaseActivityAction::read_cpp_();
    _cpp_behavior = UmlCom::read_string();
}
#endif

#ifdef WITHJAVA
void UmlBaseOpaqueAction::read_java_() {
    UmlBaseActivityAction::read_java_();
    _java_behavior = UmlCom::read_string();
}
#endif

UmlAcceptEventAction * UmlBaseAcceptEventAction::create(UmlItem * parent, const char * s)
{
    return (UmlAcceptEventAction *) parent->create_(anAcceptEventAction, s);
}

anItemKind UmlBaseAcceptEventAction::kind() {
    return anAcceptEventAction;
}

bool UmlBaseAcceptEventAction::isUnmarshall() {
    read_if_needed_();
    return _unmarshall;
}

bool UmlBaseAcceptEventAction::set_isUnmarshall(bool v) {
    return set_it_(_unmarshall, v, setUnmarshallCmd);
}

bool UmlBaseAcceptEventAction::isTimeEvent() {
    read_if_needed_();
    return _timeevent;
}

bool UmlBaseAcceptEventAction::set_isTimeEvent(bool v) {
    return set_it_(_timeevent, v, setTimeEventCmd);
}

const QCString & UmlBaseAcceptEventAction::trigger() {
    read_if_needed_();
    return _trigger;
}

bool UmlBaseAcceptEventAction::set_Trigger(const char * v) {
    return set_it_(_trigger, v, setUmlTriggerCmd);
}

#ifdef WITHCPP
const QCString & UmlBaseAcceptEventAction::cppTrigger() {
    read_if_needed_();
    return _cpp_trigger;
}

bool UmlBaseAcceptEventAction::set_CppTrigger(const char * v) {
    return set_it_(_cpp_trigger, v, setCppTriggerCmd);
}
#endif

#ifdef WITHJAVA
const QCString & UmlBaseAcceptEventAction::javaTrigger() {
    read_if_needed_();
    return _java_trigger;
}

bool UmlBaseAcceptEventAction::set_JavaTrigger(const char * v) {
    return set_it_(_java_trigger, v, setJavaTriggerCmd);
}
#endif

void UmlBaseAcceptEventAction::unload(bool rec, bool del) {
    _trigger = 0;
#ifdef WITHCPP
    _cpp_trigger = 0;
#endif
#ifdef WITHJAVA
    _java_trigger = 0;
#endif
    UmlBaseActivityAction::unload(rec, del);
}

void UmlBaseAcceptEventAction::read_uml_() {
    UmlBaseActivityAction::read_uml_();
    _unmarshall = UmlCom::read_bool();
    _timeevent = UmlCom::read_bool();
    _trigger = UmlCom::read_string();
}

#ifdef WITHCPP
void UmlBaseAcceptEventAction::read_cpp_() {
    UmlBaseActivityAction::read_cpp_();
    _cpp_trigger = UmlCom::read_string();
}
#endif

#ifdef WITHJAVA
void UmlBaseAcceptEventAction::read_java_() {
    UmlBaseActivityAction::read_java_();
    _java_trigger = UmlCom::read_string();
}
#endif

UmlCallOperationAction * UmlBaseCallOperationAction::create(UmlItem * parent, const char * s)
{
    return (UmlCallOperationAction *) parent->create_(aCallOperationAction, s);
}

anItemKind UmlBaseCallOperationAction::kind() {
    return aCallOperationAction;
}

bool UmlBaseCallOperationAction::isSynchronous() {
    read_if_needed_();
    return _synchronous;
}

bool UmlBaseCallOperationAction::set_isSynchronous(bool v) {
    return set_it_(_synchronous, v, setFlagCmd);
}

UmlOperation * UmlBaseCallOperationAction::operation() {
    read_if_needed_();
    return _operation;
}

bool UmlBaseCallOperationAction::set_Operation(UmlOperation * v) {
    UmlCom::send_cmd(_identifier, setDefCmd, ((UmlBaseItem *) v)->_identifier);   if (UmlCom::read_bool()) {     _operation = v;     return TRUE;   }   else     return FALSE;
}

void UmlBaseCallOperationAction::read_uml_() {
    UmlBaseActivityAction::read_uml_();
    _synchronous = UmlCom::read_bool();
    _operation = (UmlOperation *) UmlBaseItem::read_();
}

UmlCallBehaviorAction * UmlBaseCallBehaviorAction::create(UmlItem * parent, const char * s)
{
    return (UmlCallBehaviorAction *) parent->create_(aCallBehaviorAction, s);
}

anItemKind UmlBaseCallBehaviorAction::kind() {
    return aCallBehaviorAction;
}

bool UmlBaseCallBehaviorAction::isSynchronous() {
    read_if_needed_();
    return _synchronous;
}

bool UmlBaseCallBehaviorAction::set_isSynchronous(bool v) {
    return set_it_(_synchronous, v, setFlagCmd);
}

UmlItem * UmlBaseCallBehaviorAction::behavior() {
    read_if_needed_();
    return _behavior;
}

bool UmlBaseCallBehaviorAction::set_Behavior(UmlItem * v) {
    UmlCom::send_cmd(_identifier, setDefCmd, ((UmlBaseItem *) v)->_identifier);   if (UmlCom::read_bool()) {     _behavior = v;     return TRUE;   }   else     return FALSE;
}

void UmlBaseCallBehaviorAction::read_uml_() {
    UmlBaseActivityAction::read_uml_();
    _synchronous = UmlCom::read_bool();
    _behavior = UmlBaseItem::read_();
}

UmlClearVariableValueAction * UmlBaseClearVariableValueAction::create(UmlItem * parent, const char * s)
{
    return (UmlClearVariableValueAction *) parent->create_(aClearVariableValueAction, s);
}

anItemKind UmlBaseClearVariableValueAction::kind() {
    return aClearVariableValueAction;
}

UmlReadVariableValueAction * UmlBaseReadVariableValueAction::create(UmlItem * parent, const char * s)
{
    return (UmlReadVariableValueAction *) parent->create_(aReadVariableValueAction, s);
}

anItemKind UmlBaseReadVariableValueAction::kind() {
    return aReadVariableValueAction;
}

UmlWriteVariableValueAction * UmlBaseWriteVariableValueAction::create(UmlItem * parent, const char * s)
{
    return (UmlWriteVariableValueAction *) parent->create_(aWriteVariableValueAction, s);
}

anItemKind UmlBaseWriteVariableValueAction::kind() {
    return aWriteVariableValueAction;
}

UmlAddVariableValueAction * UmlBaseAddVariableValueAction::create(UmlItem * parent, const char * s)
{
    return (UmlAddVariableValueAction *) parent->create_(anAddVariableValueAction, s);
}

anItemKind UmlBaseAddVariableValueAction::kind() {
    return anAddVariableValueAction;
}

bool UmlBaseAddVariableValueAction::isReplaceAll() {
    read_if_needed_();
    return _replace_all;
}

bool UmlBaseAddVariableValueAction::set_isReplaceAll(bool v) {
    return set_it_(_replace_all, v, setFlagCmd);
}

void UmlBaseAddVariableValueAction::read_uml_() {
    _replace_all = UmlCom::read_bool();
    UmlBaseAccessVariableValueAction::read_uml_();
}

UmlRemoveVariableValueAction * UmlBaseRemoveVariableValueAction::create(UmlItem * parent, const char * s)
{
    return (UmlRemoveVariableValueAction *) parent->create_(aRemoveVariableValueAction, s);
}

anItemKind UmlBaseRemoveVariableValueAction::kind() {
    return aRemoveVariableValueAction;
}

bool UmlBaseRemoveVariableValueAction::isRemoveDuplicates() {
    read_if_needed_();
    return _remove_duplicates;
}

bool UmlBaseRemoveVariableValueAction::set_isRemoveDuplicates(bool v) {
    return set_it_(_remove_duplicates, v, setFlagCmd);
}

void UmlBaseRemoveVariableValueAction::read_uml_() {
    _remove_duplicates = UmlCom::read_bool();
    UmlBaseAccessVariableValueAction::read_uml_();
}