WimaPlanData.cc

#include "WimaPlanData.h"

enum Signal {
  measuremtAreaChanged,
  serviceAreaChanged,
  joinedAreaChanged,
  corridorChanged,
};

WimaPlanData::WimaPlanData(QObject *parent)
    : QObject(parent), _editing(false) {}

WimaPlanData::WimaPlanData(const WimaPlanData &other, QObject *parent)
    : QObject(parent), _editing(false) {
  *this = other;
}

WimaPlanData &WimaPlanData::operator=(const WimaPlanData &other) {
  this->_measurementArea = other._measurementArea;
  this->_serviceArea = other._serviceArea;
  this->_joinedArea = other._joinedArea;
  this->_corridor = other._corridor;

  return *this;
}

void WimaPlanData::set(const WimaJoinedAreaData &areaData) {
  if (_joinedArea != areaData) {
    _joinedArea = areaData;
    emitJoinedAreaChanged();
  }
}

void WimaPlanData::set(const WimaServiceAreaData &areaData) {
  if (_serviceArea != areaData) {
    _serviceArea = areaData;
    emitServiceAreaChanged();
  }
}

void WimaPlanData::set(const WimaCorridorData &areaData) {
  if (_corridor != areaData) {
    _corridor = areaData;
    emitCorridorChanged();
  }
}

void WimaPlanData::set(const WimaMeasurementAreaData &areaData) {
  if (_measurementArea != areaData) {
    _measurementArea = areaData;
    emitMeasurementAreaChanged();
  }
}

void WimaPlanData::clear() {
  _joinedArea = WimaJoinedAreaData();
  _serviceArea = WimaServiceAreaData();
  _corridor = WimaCorridorData();
  _measurementArea = WimaMeasurementAreaData();
}

const WimaJoinedAreaData &WimaPlanData::joinedArea() const {
  return this->_joinedArea;
}

const WimaServiceAreaData &WimaPlanData::serviceArea() const {
  return this->_serviceArea;
}

const WimaCorridorData &WimaPlanData::corridor() const {
  return this->_corridor;
}

const WimaMeasurementAreaData &WimaPlanData::measurementArea() const {
  return this->_measurementArea;
}

void WimaPlanData::startEditing() {
  if (!this->_editing) {
    this->_editing = true;
  }
}

void WimaPlanData::stopEditing() {
  if (this->_editing) {
    this->_editing = false;
    for (auto &s : this->_queuedSignals) {
      s.second();
    }
    this->_queuedSignals.clear();
  }
}

WimaPlanData::Guard WimaPlanData::guard() {
  return Guard(std::bind(&WimaPlanData::stopEditing, this));
}

bool WimaPlanData::operator==(const WimaPlanData &other) const {
  return this->_joinedArea == other._joinedArea &&
         this->_measurementArea == other._measurementArea &&
         this->_corridor == other._corridor &&
         this->_serviceArea == other._serviceArea;
}
bool WimaPlanData::operator!=(const WimaPlanData &other) const {
  return !(*this == other);
}

void WimaPlanData::emitJoinedAreaChanged() {
  if (!this->_editing) {
    emit joinedAreaChanged();
  } else {
    this->_queuedSignals.insert(
        std::make_pair(Signal::joinedAreaChanged,
                       std::bind(&WimaPlanData::joinedAreaChanged, this)));
  }
}

void WimaPlanData::emitMeasurementAreaChanged() {
  if (!this->_editing) {
    emit measurementAreaChanged();
  } else {
    this->_queuedSignals.insert(
        std::make_pair(Signal::measuremtAreaChanged,
                       std::bind(&WimaPlanData::measurementAreaChanged, this)));
  }
}

void WimaPlanData::emitServiceAreaChanged() {
  if (!this->_editing) {
    emit serviceAreaChanged();
  } else {
    this->_queuedSignals.insert(
        std::make_pair(Signal::serviceAreaChanged,
                       std::bind(&WimaPlanData::serviceAreaChanged, this)));
  }
}

void WimaPlanData::emitCorridorChanged() {
  if (!this->_editing) {
    emit corridorChanged();
  } else {
    this->_queuedSignals.insert(
        std::make_pair(Signal::corridorChanged,
                       std::bind(&WimaPlanData::corridorChanged, this)));
  }
}