SchemaCommand.cpp

Go to the documentation of this file.

// DUNE DAQ modification notice:
// This file has been modified from the original ATLAS dbe source for the DUNE DAQ project.
// Fork baseline commit: dbe-02-12-17 (2022-05-12).
// Renamed since fork: yes (from src/SchemaEditor/SchemaCommand.cpp to apps/SchemaEditor/SchemaCommand.cpp).

#include <QMessageBox>
#include "dbe/SchemaCommand.hpp"
#include "dbe/SchemaKernelWrapper.hpp"
 
using namespace dunedaq::oks;
 
namespace dbse {
 
SetAbstractClassCommand::SetAbstractClassCommand(OksClass* Class, bool Value)
  : ClassName(Class->get_name())
  , NewValue(Value)
  , OldValue(Class->get_is_abstract())
{
  setText(QString::fromStdString("Changed abstract flag for class \"" + ClassName + "\""));
}
 
SetAbstractClassCommand::~SetAbstractClassCommand() {}
 
void
SetAbstractClassCommand::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->set_is_abstract(NewValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAbstractClassCommand::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->set_is_abstract(OldValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetDescriptionClassCommand::SetDescriptionClassCommand(OksClass* Class, std::string Description)
  : ClassName(Class->get_name())
  , NewDescription(Description)
  , OldDescription(Class->get_description())
{
  setText(QString::fromStdString("Changed description for class \"" + ClassName + "\""));
}
 
SetDescriptionClassCommand::~SetDescriptionClassCommand() {}
 
void
SetDescriptionClassCommand::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->set_description(NewDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetDescriptionClassCommand::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->set_description(OldDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
CreateClassCommand::CreateClassCommand(std::string ClassName, std::string ClassDescription, bool Abstract)
  : SchemaClass(nullptr)
  , SchemaClassName(ClassName)
  , SchemaClassDescription(ClassDescription)
  , SchemaAbstract(Abstract)
{
  setText(QString::fromStdString("Created new class \"" + ClassName + "\""));
}
 
CreateClassCommand::~CreateClassCommand() {}
 
void
CreateClassCommand::redo()
{
  SchemaClass =
    new OksClass(SchemaClassName, SchemaClassDescription, SchemaAbstract, KernelWrapper::GetInstance().GetKernel());
  emit KernelWrapper::GetInstance().ClassCreated(QString::fromStdString(SchemaClassName));
}
 
void
CreateClassCommand::undo()
{
  try {
    OksClass::destroy(SchemaClass);
    emit KernelWrapper::GetInstance().ClassRemoved(QString::fromStdString(SchemaClassName));
  } catch (...) {
    QMessageBox::warning(0, "Schema editor", QString("Error"));
  }
}
 
RemoveClassCommand::RemoveClassCommand(OksClass* Class,
                                       std::string ClassName,
                                       std::string ClassDescription,
                                       bool Abstract)
  : SchemaClass(Class)
  , SchemaClassName(ClassName)
  , SchemaClassDescription(ClassDescription)
  , SchemaAbstract(Abstract)
{
  setText(QString::fromStdString("Removed class \"" + ClassName + "\""));
}
 
RemoveClassCommand::~RemoveClassCommand() {}
 
void
RemoveClassCommand::redo()
{
  OksClass::destroy(SchemaClass);
  emit KernelWrapper::GetInstance().ClassRemoved(QString::fromStdString(SchemaClassName));
}
 
void
RemoveClassCommand::undo()
{
  SchemaClass =
    new OksClass(SchemaClassName, SchemaClassDescription, SchemaAbstract, KernelWrapper::GetInstance().GetKernel());
  emit KernelWrapper::GetInstance().ClassCreated(QString::fromStdString(SchemaClassName));
}
 
AddSuperClassCommand::AddSuperClassCommand(OksClass* Class, std::string SuperClass)
  : ClassName(Class->get_name())
  , NewSuperClass(SuperClass)
{
  setText(QString::fromStdString("Added new super-class \"" + SuperClass + "\" to class \"" + ClassName + "\""));
}
 
AddSuperClassCommand::~AddSuperClassCommand() {}
 
void
AddSuperClassCommand::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->add_super_class(NewSuperClass);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
AddSuperClassCommand::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove_super_class(NewSuperClass);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
RemoveSuperClassCommand::RemoveSuperClassCommand(OksClass* Class, std::string superClass)
  : ClassName(Class->get_name())
  , SuperClass(superClass)
{
  setText(QString::fromStdString("Removed super-class \"" + superClass + "\" from class \"" + ClassName + "\""));
}
 
RemoveSuperClassCommand::~RemoveSuperClassCommand() {}
 
void
RemoveSuperClassCommand::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove_super_class(SuperClass);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
RemoveSuperClassCommand::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->add_super_class(SuperClass);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetNameRelationshipCommand::SetNameRelationshipCommand(OksClass* Class, OksRelationship* Relationship, std::string Name)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , NewRelationshipName(Name)
  , OldRelationshipName(SchemaRelationship->get_name())
{
  setText(QString::fromStdString("Changed relationship \"" + Relationship->get_name() + "\" to \"" + Name +
                                 "\" for class \"" + ClassName + "\""));
}
 
SetNameRelationshipCommand::~SetNameRelationshipCommand() {}
 
void
SetNameRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(OldRelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_name(NewRelationshipName);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetNameRelationshipCommand::undo()
{
  SchemaRelationship->set_name(OldRelationshipName);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetClassTypeRelationshipCommand::SetClassTypeRelationshipCommand(OksClass* Class,
                                                                 OksRelationship* Relationship,
                                                                 std::string ClassType)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewRelationshipType(ClassType)
  , OldRelationshipType(SchemaRelationship->get_type())
{
  setText(QString::fromStdString("Relationship \"" + SchemaRelationship->get_name() + "\" set to type \"" +
                                 NewRelationshipType + "\" for class \"" + ClassName + "\""));
}
 
SetClassTypeRelationshipCommand::~SetClassTypeRelationshipCommand() {}
 
void
SetClassTypeRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_type(NewRelationshipType);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetClassTypeRelationshipCommand::undo()
{
  SchemaRelationship->set_type(OldRelationshipType);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetDescriptionRelationshipCommand::SetDescriptionRelationshipCommand(OksClass* Class,
                                                                     OksRelationship* Relationship,
                                                                     std::string Description)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewDescription(Description)
  , OldDescription(SchemaRelationship->get_description())
{
  setText(QString::fromStdString("Changed description of relationship \"" + Relationship->get_name() +
                                 "\" for class \"" + ClassName + "\""));
}
 
SetDescriptionRelationshipCommand::~SetDescriptionRelationshipCommand() {}
 
void
SetDescriptionRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_description(NewDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetDescriptionRelationshipCommand::undo()
{
  SchemaRelationship->set_description(OldDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetLowCcRelationshipCommand::SetLowCcRelationshipCommand(OksClass* Class,
                                                         OksRelationship* Relationship,
                                                         OksRelationship::CardinalityConstraint NewCardinality)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewLowCc(NewCardinality)
  , OldLowCc(SchemaRelationship->get_low_cardinality_constraint())
{
  setText(QString::fromStdString("Changed low cardinality constraint for relationship \"" + Relationship->get_name() +
                                 "\" of class \"" + ClassName + "\""));
}
 
SetLowCcRelationshipCommand::~SetLowCcRelationshipCommand() {}
 
void
SetLowCcRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_low_cardinality_constraint(NewLowCc);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetLowCcRelationshipCommand::undo()
{
  SchemaRelationship->set_low_cardinality_constraint(OldLowCc);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetHighCcRelationshipCommand::SetHighCcRelationshipCommand(OksClass* Class,
                                                           OksRelationship* Relationship,
                                                           OksRelationship::CardinalityConstraint NewCardinality)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewHighCc(NewCardinality)
  , OldHighCc(SchemaRelationship->get_high_cardinality_constraint())
{
  setText(QString::fromStdString("Changed high cardinality constraint for relationship \"" + Relationship->get_name() +
                                 "\" of class \"" + ClassName + "\""));
}
 
SetHighCcRelationshipCommand::~SetHighCcRelationshipCommand() {}
 
void
SetHighCcRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_high_cardinality_constraint(NewHighCc);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetHighCcRelationshipCommand::undo()
{
  SchemaRelationship->set_high_cardinality_constraint(OldHighCc);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetIsCompositeRelationshipCommand::SetIsCompositeRelationshipCommand(OksClass* Class,
                                                                     OksRelationship* Relationship,
                                                                     bool Value)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewValue(Value)
  , OldValue(SchemaRelationship->get_is_composite())
{
  setText(QString::fromStdString("Changed the \"is composite\" constraint for relationship \"" +
                                 Relationship->get_name() + "\" of class \"" + ClassName + "\""));
}
 
SetIsCompositeRelationshipCommand::~SetIsCompositeRelationshipCommand() {}
 
void
SetIsCompositeRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_is_composite(NewValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetIsCompositeRelationshipCommand::undo()
{
  SchemaRelationship->set_is_composite(OldValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetIsDependentRelationshipCommand::SetIsDependentRelationshipCommand(OksClass* Class,
                                                                     OksRelationship* Relationship,
                                                                     bool Value)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewValue(Value)
  , OldValue(SchemaRelationship->get_is_dependent())
{
  setText(QString::fromStdString("Changed the \"is dependent\" constraint for relationship \"" +
                                 Relationship->get_name() + "\" of class \"" + ClassName + "\""));
}
 
SetIsDependentRelationshipCommand::~SetIsDependentRelationshipCommand() {}
 
void
SetIsDependentRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_is_dependent(NewValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetIsDependentRelationshipCommand::undo()
{
  SchemaRelationship->set_is_dependent(OldValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetIsExclusiveRelationshipCommand::SetIsExclusiveRelationshipCommand(OksClass* Class,
                                                                     OksRelationship* Relationship,
                                                                     bool Value)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Relationship->get_name())
  , NewValue(Value)
  , OldValue(SchemaRelationship->get_is_exclusive())
{
  setText(QString::fromStdString("Changed the \"is exclusive\" constraint for relationship \"" +
                                 Relationship->get_name() + "\" of class \"" + ClassName + "\""));
}
 
SetIsExclusiveRelationshipCommand::~SetIsExclusiveRelationshipCommand() {}
 
void
SetIsExclusiveRelationshipCommand::redo()
{
  OksRelationship* r = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_relationship(RelationshipName);
  if (r != nullptr) {
    SchemaRelationship = r;
  }
 
  SchemaRelationship->set_is_exclusive(NewValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetIsExclusiveRelationshipCommand::undo()
{
  SchemaRelationship->set_is_exclusive(OldValue);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
AddRelationship::AddRelationship(OksClass* Class,
                                 std::string Name,
                                 std::string Description,
                                 std::string Type,
                                 bool Composite,
                                 bool Exclusive,
                                 bool Dependent,
                                 OksRelationship::CardinalityConstraint LowCc,
                                 OksRelationship::CardinalityConstraint HighCc)
  : ClassName(Class->get_name())
  , SchemaRelationship(nullptr)
  , RelationshipName(Name)
  , RelationshipDescription(Description)
  , RelationshipType(Type)
  , IsComposite(Composite)
  , IsExclusive(Exclusive)
  , IsDependent(Dependent)
  , RelationshipLowCc(LowCc)
  , RelationshipHighCc(HighCc)
{
  setText(QString::fromStdString("Added relationship \"" + Name + "\" to class \"" + Class->get_name() + "\""));
}
 
AddRelationship::~AddRelationship() {}
 
void
AddRelationship::redo()
{
  if (SchemaRelationship == nullptr) {
    SchemaRelationship = new OksRelationship(RelationshipName,
                                             RelationshipType,
                                             RelationshipLowCc,
                                             RelationshipHighCc,
                                             IsComposite,
                                             IsExclusive,
                                             IsDependent,
                                             RelationshipDescription);
  }
 
  KernelWrapper::GetInstance().FindClass(ClassName)->add(SchemaRelationship);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
AddRelationship::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove(SchemaRelationship, false);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
RemoveRelationship::RemoveRelationship(OksClass* Class,
                                       OksRelationship* Relationship,
                                       std::string Name,
                                       std::string Description,
                                       std::string Type,
                                       bool Composite,
                                       bool Exclusive,
                                       bool Dependent,
                                       OksRelationship::CardinalityConstraint LowCc,
                                       OksRelationship::CardinalityConstraint HighCc)
  : ClassName(Class->get_name())
  , SchemaRelationship(Relationship)
  , RelationshipName(Name)
  , RelationshipDescription(Description)
  , RelationshipType(Type)
  , IsComposite(Composite)
  , IsExclusive(Exclusive)
  , IsDependent(Dependent)
  , RelationshipLowCc(LowCc)
  , RelationshipHighCc(HighCc)
{
  setText(QString::fromStdString("Removed relationship \"" + Name + "\" to class \"" + Class->get_name() + "\""));
}
 
RemoveRelationship::~RemoveRelationship() {}
 
void
RemoveRelationship::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove(SchemaRelationship, false);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
RemoveRelationship::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->add(SchemaRelationship);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetMethodImplementationLanguage::SetMethodImplementationLanguage(OksClass* Class,
                                                                 OksMethod* Method,
                                                                 OksMethodImplementation* Implementation,
                                                                 std::string Language)
  : ClassName(Class->get_name())
  , MethodName(Method->get_name())
  , SchemaImplementation(Implementation)
  , NewLanguage(Language)
  , OldLanguage(SchemaImplementation->get_language())
{
  setText(QString::fromStdString("Changed language implementation for \"" + SchemaImplementation->get_prototype() +
                                 "\" of class \"" + Class->get_name() + "\""));
}
 
SetMethodImplementationLanguage::~SetMethodImplementationLanguage() {}
 
void
SetMethodImplementationLanguage::redo()
{
  OksMethodImplementation* mi =
    KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_method(MethodName)->find_implementation(OldLanguage);
  if (mi != nullptr) {
    SchemaImplementation = mi;
  }
 
  SchemaImplementation->set_language(NewLanguage);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetMethodImplementationLanguage::undo()
{
  SchemaImplementation->set_language(OldLanguage);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetMethodImplementationPrototype::SetMethodImplementationPrototype(OksClass* Class,
                                                                   OksMethod* Method,
                                                                   OksMethodImplementation* Implementation,
                                                                   std::string Prototype)
  : ClassName(Class->get_name())
  , MethodName(Method->get_name())
  , SchemaImplementation(Implementation)
  , ImplementationLanguage(Implementation->get_language())
  , NewPrototype(Prototype)
  , OldPrototype(SchemaImplementation->get_prototype())
{
  setText(QString::fromStdString("Changed prototype for method \"" + SchemaImplementation->get_prototype() +
                                 "\" of class \"" + ClassName + "\""));
}
 
SetMethodImplementationPrototype::~SetMethodImplementationPrototype() {}
 
void
SetMethodImplementationPrototype::redo()
{
  OksMethodImplementation* mi = KernelWrapper::GetInstance()
                                  .FindClass(ClassName)
                                  ->find_direct_method(MethodName)
                                  ->find_implementation(ImplementationLanguage);
  if (mi != nullptr) {
    SchemaImplementation = mi;
  }
 
  SchemaImplementation->set_prototype(NewPrototype);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetMethodImplementationPrototype::undo()
{
  SchemaImplementation->set_prototype(OldPrototype);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetMethodImplementationBody::SetMethodImplementationBody(OksClass* Class,
                                                         OksMethod* Method,
                                                         OksMethodImplementation* Implementation,
                                                         std::string Body)
  : ClassName(Class->get_name())
  , MethodName(Method->get_name())
  , SchemaImplementation(Implementation)
  , ImplementationLanguage(Implementation->get_language())
  , NewBody(Body)
  , OldBody(SchemaImplementation->get_body())
{
  setText(QString::fromStdString("Changed body implementation for method \"" + SchemaImplementation->get_prototype() +
                                 "\" of class \"" + Class->get_name() + "\""));
}
 
SetMethodImplementationBody::~SetMethodImplementationBody() {}
 
void
SetMethodImplementationBody::redo()
{
  OksMethodImplementation* mi = KernelWrapper::GetInstance()
                                  .FindClass(ClassName)
                                  ->find_direct_method(MethodName)
                                  ->find_implementation(ImplementationLanguage);
  if (mi != nullptr) {
    SchemaImplementation = mi;
  }
 
  SchemaImplementation->set_body(NewBody);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetMethodImplementationBody::undo()
{
  SchemaImplementation->set_body(OldBody);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
AddMethodImplementationComand::AddMethodImplementationComand(OksClass* Class,
                                                             OksMethod* Method,
                                                             std::string Language,
                                                             std::string Prototype,
                                                             std::string Body)
  : ClassName(Class->get_name())
  , SchemaMethod(Method)
  , MethodName(Method->get_name())
  , SchemaImplementationLanguage(Language)
  , SchemaImplementationPrototype(Prototype)
  , SchemaImplementationBody(Body)
{
  setText(QString::fromStdString("Added implementation for method \"" + SchemaMethod->get_name() + "\" for class \"" +
                                 Class->get_name() + "\""));
}
 
AddMethodImplementationComand::~AddMethodImplementationComand() {}
 
void
AddMethodImplementationComand::redo()
{
  OksMethod* m = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_method(MethodName);
  if (m != nullptr) {
    SchemaMethod = m;
  }
 
  SchemaMethod->add_implementation(
    SchemaImplementationLanguage, SchemaImplementationPrototype, SchemaImplementationBody);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
AddMethodImplementationComand::undo()
{
  SchemaMethod->remove_implementation(SchemaImplementationLanguage);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
RemoveMethodImplementationComand::RemoveMethodImplementationComand(OksClass* Class,
                                                                   OksMethod* Method,
                                                                   std::string Language,
                                                                   std::string Prototype,
                                                                   std::string Body)
  : ClassName(Class->get_name())
  , SchemaMethod(Method)
  , MethodName(Method->get_name())
  , SchemaImplementationLanguage(Language)
  , SchemaImplementationPrototype(Prototype)
  , SchemaImplementationBody(Body)
{
  setText(QString::fromStdString("Removed implementation for method \"" + SchemaMethod->get_name() + "\" for class \"" +
                                 Class->get_name() + "\""));
}
 
RemoveMethodImplementationComand::~RemoveMethodImplementationComand() {}
 
void
RemoveMethodImplementationComand::redo()
{
  OksMethod* m = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_method(MethodName);
  if (m != nullptr) {
    SchemaMethod = m;
  }
 
  SchemaMethod->remove_implementation(SchemaImplementationLanguage);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
RemoveMethodImplementationComand::undo()
{
  SchemaMethod->add_implementation(
    SchemaImplementationLanguage, SchemaImplementationPrototype, SchemaImplementationBody);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetNameMethodCommand::SetNameMethodCommand(OksClass* Class, OksMethod* Method, std::string name)
  : ClassName(Class->get_name())
  , SchemaMethod(Method)
  , NewMethodName(name)
  , OldMethodName(SchemaMethod->get_name())
{
  setText(QString::fromStdString("Set name for method \"" + SchemaMethod->get_name() + "\" of class \"" +
                                 Class->get_name() + "\""));
}
 
SetNameMethodCommand::~SetNameMethodCommand() {}
 
void
SetNameMethodCommand::redo()
{
  OksMethod* m = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_method(OldMethodName);
  if (m != nullptr) {
    SchemaMethod = m;
  }
 
  SchemaMethod->set_name(NewMethodName);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetNameMethodCommand::undo()
{
  SchemaMethod->set_name(OldMethodName);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetDescriptionMethodCommand::SetDescriptionMethodCommand(OksClass* Class, OksMethod* Method, std::string description)
  : ClassName(Class->get_name())
  , SchemaMethod(Method)
  , MethodName(Method->get_name())
  , NewMethodDescription(description)
  , OldMethodDescription(SchemaMethod->get_description())
{
  setText(QString::fromStdString("Set description for method \"" + SchemaMethod->get_name() + "\" of class \"" +
                                 Class->get_name() + "\""));
}
 
SetDescriptionMethodCommand::~SetDescriptionMethodCommand() {}
 
void
SetDescriptionMethodCommand::redo()
{
  OksMethod* m = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_method(MethodName);
  if (m != nullptr) {
    SchemaMethod = m;
  }
  SchemaMethod->set_description(NewMethodDescription);
 
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetDescriptionMethodCommand::undo()
{
  SchemaMethod->set_description(OldMethodDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
AddMethodCommand::AddMethodCommand(OksClass* Class, std::string name, std::string description)
  : ClassName(Class->get_name())
  , SchemaMethod(nullptr)
  , SchemaName(name)
  , SchemaDescription(description)
{
  setText(QString::fromStdString("Added method \"" + name + "\" to class \"" + Class->get_name() + "\""));
}
 
AddMethodCommand::~AddMethodCommand() {}
 
void
AddMethodCommand::redo()
{
  SchemaMethod = new OksMethod(SchemaName, SchemaDescription);
  KernelWrapper::GetInstance().FindClass(ClassName)->add(SchemaMethod);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
AddMethodCommand::undo()
{
  // Do not delete SchemaMethod (probably deleted internally by the OKS library)
  KernelWrapper::GetInstance().FindClass(ClassName)->remove(SchemaMethod);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
RemoveMethodCommand::RemoveMethodCommand(OksClass* Class, OksMethod* Method, std::string name, std::string description)
  : ClassName(Class->get_name())
  , SchemaMethod(Method)
  , SchemaName(name)
  , SchemaDescription(description)
{
  setText(QString::fromStdString("Removed method \"" + name + "\" to class \"" + Class->get_name() + "\""));
}
 
RemoveMethodCommand::~RemoveMethodCommand() {}
 
void
RemoveMethodCommand::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove(SchemaMethod);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
RemoveMethodCommand::undo()
{
  SchemaMethod = new OksMethod(SchemaName, SchemaDescription);
  KernelWrapper::GetInstance().FindClass(ClassName)->add(SchemaMethod);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeNameCommand::SetAttributeNameCommand(OksClass* Class, OksAttribute* Attribute, std::string NewName)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , NewAttributeName(NewName)
  , OldAttributeName(SchemaAttribute->get_name())
{
  setText(QString::fromStdString("Set new name \"" + NewName + "\" to attribute \"" + Attribute->get_name() +
                                 "\" of class \"" + ClassName + "\""));
}
 
SetAttributeNameCommand::~SetAttributeNameCommand() {}
 
void
SetAttributeNameCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(OldAttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_name(NewAttributeName);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeNameCommand::undo()
{
  SchemaAttribute->set_name(OldAttributeName);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeTypeCommand::SetAttributeTypeCommand(OksClass* Class, OksAttribute* Attribute, std::string NewType)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeType(NewType)
  , OldAttributeType(SchemaAttribute->get_type())
{
  setText(QString::fromStdString("Set new type \"" + NewType + "\" to attribute \"" + Attribute->get_name() +
                                 "\" of class \"" + ClassName + "\""));
}
 
SetAttributeTypeCommand::~SetAttributeTypeCommand() {}
 
void
SetAttributeTypeCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_type(NewAttributeType);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeTypeCommand::undo()
{
  SchemaAttribute->set_type(OldAttributeType);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeRangeCommand::SetAttributeRangeCommand(OksClass* Class, OksAttribute* Attribute, std::string NewRange)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeRange(NewRange)
  , OldAttributeRange(SchemaAttribute->get_range())
{
  setText(QString::fromStdString("Set new range \"" + NewRange + "\" to attribute \"" + Attribute->get_name() +
                                 "\" of class \"" + ClassName + "\""));
}
 
SetAttributeRangeCommand::~SetAttributeRangeCommand() {}
 
void
SetAttributeRangeCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_range(NewAttributeRange);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeRangeCommand::undo()
{
  SchemaAttribute->set_range(OldAttributeRange);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeFormatCommand::SetAttributeFormatCommand(OksClass* Class,
                                                     OksAttribute* Attribute,
                                                     OksAttribute::Format NewFormat)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeFormat(NewFormat)
  , OldAttributeFormat(SchemaAttribute->get_format())
{
  setText(QString::fromStdString("Set new format for attribute \"" + Attribute->get_name() + "\" of class \"" +
                                 ClassName + "\""));
}
 
SetAttributeFormatCommand::~SetAttributeFormatCommand() {}
 
void
SetAttributeFormatCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_format(NewAttributeFormat);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeFormatCommand::undo()
{
  SchemaAttribute->set_format(OldAttributeFormat);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeMultiCommand::SetAttributeMultiCommand(OksClass* Class, OksAttribute* Attribute, bool NewIsMulti)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeMulti(NewIsMulti)
  , OldAttributeMulti(SchemaAttribute->get_is_multi_values())
{
  setText(QString::fromStdString("Set multiplicity for attribute \"" + Attribute->get_name() + "\" of class \"" +
                                 ClassName + "\""));
}
 
SetAttributeMultiCommand::~SetAttributeMultiCommand() {}
 
void
SetAttributeMultiCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_is_multi_values(NewAttributeMulti);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeMultiCommand::undo()
{
  SchemaAttribute->set_is_multi_values(OldAttributeMulti);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeIsNullCommand::SetAttributeIsNullCommand(OksClass* Class, OksAttribute* Attribute, bool NewIsNull)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeIsNull(NewIsNull)
  , OldAttributeIsNull(SchemaAttribute->get_is_no_null())
{
  setText(QString::fromStdString("Set null-ness for attribute \"" + Attribute->get_name() + "\" of class \"" +
                                 ClassName + "\""));
}
 
SetAttributeIsNullCommand::~SetAttributeIsNullCommand() {}
 
void
SetAttributeIsNullCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_is_no_null(NewAttributeIsNull);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeIsNullCommand::undo()
{
  SchemaAttribute->set_is_no_null(OldAttributeIsNull);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeInitialValuesCommand::SetAttributeInitialValuesCommand(OksClass* Class,
                                                                   OksAttribute* Attribute,
                                                                   std::string NewValues)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeInitialValues(NewValues)
  , OldAttributeInitialValues(SchemaAttribute->get_init_value())
{
  setText(QString::fromStdString("Set new initial values to attribute \"" + Attribute->get_name() + "\" of class \"" +
                                 ClassName + "\""));
}
 
SetAttributeInitialValuesCommand::~SetAttributeInitialValuesCommand() {}
 
void
SetAttributeInitialValuesCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_init_value(NewAttributeInitialValues);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeInitialValuesCommand::undo()
{
  SchemaAttribute->set_init_value(OldAttributeInitialValues);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
AddAttributeCommand::AddAttributeCommand(OksClass* Class,
                                         std::string name,
                                         std::string type,
                                         bool is_mv,
                                         std::string range,
                                         std::string init_values,
                                         std::string description,
                                         bool is_null,
                                         OksAttribute::Format format)
  : ClassName(Class->get_name())
  , SchemaAttribute(nullptr)
  , SchemaName(name)
  , SchemaType(type)
  , SchemaIsMulti(is_mv)
  , SchemaRange(range)
  , SchemaInitValues(init_values)
  , SchemaDescription(description)
  , SchemaIsNull(is_null)
  , SchemaFormat(format)
{
  setText(QString::fromStdString("Added attribute \"" + name + "\" to class \"" + Class->get_name() + "\""));
}
 
AddAttributeCommand::~AddAttributeCommand() {}
 
void
AddAttributeCommand::redo()
{
  SchemaAttribute = new OksAttribute(SchemaName,
                                     SchemaType,
                                     SchemaIsMulti,
                                     SchemaRange,
                                     SchemaInitValues,
                                     SchemaDescription,
                                     SchemaIsNull,
                                     SchemaFormat);
  KernelWrapper::GetInstance().FindClass(ClassName)->add(SchemaAttribute);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
AddAttributeCommand::undo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove(SchemaAttribute);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
RemoveAttributeCommand::RemoveAttributeCommand(OksClass* Class,
                                               OksAttribute* Attribute,
                                               std::string name,
                                               std::string type,
                                               bool is_mv,
                                               std::string range,
                                               std::string init_values,
                                               std::string description,
                                               bool is_null,
                                               OksAttribute::Format format)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , SchemaName(name)
  , SchemaType(type)
  , SchemaIsMulti(is_mv)
  , SchemaRange(range)
  , SchemaInitValues(init_values)
  , SchemaDescription(description)
  , SchemaIsNull(is_null)
  , SchemaFormat(format)
{
  setText(QString::fromStdString("Removed attribute \"" + name + "\" from class \"" + Class->get_name() + "\""));
}
 
RemoveAttributeCommand::~RemoveAttributeCommand() {}
 
void
RemoveAttributeCommand::redo()
{
  KernelWrapper::GetInstance().FindClass(ClassName)->remove(SchemaAttribute);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
RemoveAttributeCommand::undo()
{
  SchemaAttribute = new OksAttribute(SchemaName,
                                     SchemaType,
                                     SchemaIsMulti,
                                     SchemaRange,
                                     SchemaInitValues,
                                     SchemaDescription,
                                     SchemaIsNull,
                                     SchemaFormat);
  KernelWrapper::GetInstance().FindClass(ClassName)->add(SchemaAttribute);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
SetAttributeDescriptionCommand::SetAttributeDescriptionCommand(OksClass* Class,
                                                               OksAttribute* Attribute,
                                                               std::string NewDescription)
  : ClassName(Class->get_name())
  , SchemaAttribute(Attribute)
  , AttributeName(Attribute->get_name())
  , NewAttributeDescription(NewDescription)
  , OldAttributeDescription(SchemaAttribute->get_description())
{
  setText(QString::fromStdString("Set description for attribute \"" + Attribute->get_name() + "\" of class \"" +
                                 ClassName + "\""));
}
 
SetAttributeDescriptionCommand::~SetAttributeDescriptionCommand() {}
 
void
SetAttributeDescriptionCommand::redo()
{
  OksAttribute* a = KernelWrapper::GetInstance().FindClass(ClassName)->find_direct_attribute(AttributeName);
  if (a != nullptr) {
    SchemaAttribute = a;
  }
 
  SchemaAttribute->set_description(NewAttributeDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
void
SetAttributeDescriptionCommand::undo()
{
  SchemaAttribute->set_description(OldAttributeDescription);
  emit KernelWrapper::GetInstance().ClassUpdated(QString::fromStdString(ClassName));
}
 
} // end namespace dbse