AbstractTableModel.cpp

#include "IsisDebug.h"

#include <cmath>
#include <iostream>

#include <QCoreApplication>
#include <QDateTime>
#include <QDebug>
#include <QFutureWatcher>
#include <QSettings>
#include <QtConcurrentRun>
#include <QTimer>

#include "IException.h"
#include "IString.h"

#include "AbstractTableDelegate.h"
#include "AbstractTableModel.h"
#include "BusyLeafItem.h"
#include "TableColumn.h"
#include "TableColumnList.h"
#include "TableView.h"
#include "AbstractTreeModel.h"


namespace Isis {
  namespace CnetViz {
    AbstractTableModel::AbstractTableModel(AbstractTreeModel *model,
        AbstractTableDelegate *someDelegate) {
      nullify();

      m_dataModel = model;
      connect(model, SIGNAL(cancelSort()), this, SLOT(cancelSort()));

      m_delegate = someDelegate;

      m_sortingEnabled = false;
      m_sortLimit = 10000;
      m_sorting = false;

      m_sortedItems = new QList<AbstractTreeItem *>;
      m_busyItem = new BusyLeafItem;
      m_sortStatusPoller = new QTimer;

      m_sortingWatcher = new QFutureWatcher< QList< AbstractTreeItem * > >;
      connect(m_sortingWatcher, SIGNAL(finished()), this, SLOT(sortFinished()));

      connect(m_sortStatusPoller, SIGNAL(timeout()),
          this, SLOT(sortStatusUpdated()));

      // Signal forwarding
      connect(model, SIGNAL(modelModified()), SLOT(rebuildSort()));

      connect(model, SIGNAL(filterProgressChanged(int)),
          this, SIGNAL(filterProgressChanged(int)));

      connect(model, SIGNAL(rebuildProgressChanged(int)),
          this, SIGNAL(rebuildProgressChanged(int)));

      connect(model, SIGNAL(filterProgressRangeChanged(int, int)),
          this, SIGNAL(filterProgressRangeChanged(int, int)));

      connect(model, SIGNAL(rebuildProgressRangeChanged(int, int)),
          this, SIGNAL(rebuildProgressRangeChanged(int, int)));

      connect(this, SIGNAL(tableSelectionChanged(QList<AbstractTreeItem *>)),
          model, SIGNAL(tableSelectionChanged(QList<AbstractTreeItem *>)));
      connect(model, SIGNAL(filterCountsChanged(int, int)),
          this, SIGNAL(filterCountsChanged(int, int)));
    }


    AbstractTableModel::~AbstractTableModel() {
      cancelSort();

      m_dataModel = NULL;

      delete m_delegate;
      m_delegate = NULL;

      delete m_sortedItems;
      m_sortedItems = NULL;

      delete m_busyItem;
      m_busyItem = NULL;

      delete m_sortStatusPoller;
      m_sortStatusPoller = NULL;

      delete m_lessThanFunctor;
      m_lessThanFunctor = NULL;

      if (m_columns) {
        for (int i = 0; i < m_columns->size(); i++)
          delete(*m_columns)[i];

        delete m_columns;
        m_columns = NULL;
      }

      delete m_sortingWatcher;
      m_sortingWatcher = NULL;
    }


    bool AbstractTableModel::isSorting() const {
      return m_sorting;
    }


    bool AbstractTableModel::isFiltering() const {
      return m_dataModel && m_dataModel->isFiltering();
    }


    bool AbstractTableModel::sortingIsEnabled() const {
      return m_sortingEnabled;
    }


    void AbstractTableModel::setSortingEnabled(bool enabled) {
      if (m_sortingEnabled != enabled) {
        m_sortingEnabled = enabled;
        rebuildSort();
      }
    }


    int AbstractTableModel::sortLimit() const {
      return m_sortLimit;
    }


    void AbstractTableModel::setSortLimit(int limit) {
      if (m_sortLimit != limit) {
        m_sortLimit = limit;
        rebuildSort();
      }
    }


    bool AbstractTableModel::sortingOn() const {
      return (sortingIsEnabled() && (getVisibleRowCount() <= sortLimit()));
    }


    TableColumnList *AbstractTableModel::getColumns() {
      if (!m_columns) {
        m_columns = createColumns();
        connect(m_columns, SIGNAL(sortOutDated()), this, SLOT(sort()));
      }

      return m_columns;
    }


    const AbstractTableDelegate *AbstractTableModel::getDelegate() const {
      return m_delegate;
    }


    void AbstractTableModel::applyFilter() {
      getDataModel()->applyFilter();
    }


    void AbstractTableModel::sort() {
      if (sortingOn() && m_sortedItems->size() && !m_dataModel->isFiltering() &&
          !m_dataModel->isRebuilding()) {
        if (isSorting()) {
          cancelSort();
        }
        else if (!m_lessThanFunctor) {
          // Create a new comparison functor to be used in the m_sort. It will
          // keep track of the number of comparisons made so that we can make a
          // guess at the progress of the m_sort.
          m_lessThanFunctor = new LessThanFunctor(
            m_columns->getSortingOrder().first());

          // Sorting is always done on a COPY of the items list.
          QFuture< QList< AbstractTreeItem * > > future =
            QtConcurrent::run(this, &AbstractTableModel::doSort,
                *m_sortedItems);
          m_sortingWatcher->setFuture(future);

          emit modelModified();
        }
      }
    }


    void AbstractTableModel::reverseOrder(TableColumn *column) {
    }


    void AbstractTableModel::updateSort() {
    }


    AbstractTreeModel *AbstractTableModel::getDataModel() {
      ASSERT(m_dataModel);
      return m_dataModel;
    }


    const AbstractTreeModel *AbstractTableModel::getDataModel() const {
      ASSERT(m_dataModel);
      return m_dataModel;
    }


    QList< AbstractTreeItem * > AbstractTableModel::getSortedItems(
      int start, int end, AbstractTreeModel::InterestingItems flags) {
      QList< AbstractTreeItem * > sortedSubsetOfItems;

      if (sortingOn()) {
        while (start <= end) {
          if (start < m_sortedItems->size())
            sortedSubsetOfItems.append(m_sortedItems->at(start));
          else if (isFiltering())
            sortedSubsetOfItems.append(m_busyItem);

          start++;
        }
      }
      else {
        sortedSubsetOfItems = getDataModel()->getItems(start, end, flags, true);
      }

      return sortedSubsetOfItems;
    }


    QList< AbstractTreeItem * > AbstractTableModel::getSortedItems(
      AbstractTreeItem *item1, AbstractTreeItem *item2,
      AbstractTreeModel::InterestingItems flags) {
      QList< AbstractTreeItem * > sortedSubsetOfItems;

      if (!sortingOn()) {
        sortedSubsetOfItems = getDataModel()->getItems(item1, item2, flags, true);
      }
      else {
        AbstractTreeItem *start = NULL;

        int currentIndex = 0;

        while (!start && currentIndex < m_sortedItems->size()) {
          AbstractTreeItem *current = m_sortedItems->at(currentIndex);
          if (current == item1)
            start = item1;
          else if (current == item2)
            start = item2;

          if (!start)
            currentIndex++;
        }

        if (!start) {
          IString msg = "Could not find the first item";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }

        AbstractTreeItem *end = item2;

        // Sometimes we need to build the list forwards and sometimes backwards.
        // This is accomplished by using either append or prepend.  We abstract
        // away which of these we should use (why should we care) by using the
        // variable "someKindaPend" to store the appropriate method.
        void (QList< AbstractTreeItem * >::*someKindaPend)(
          AbstractTreeItem * const &);
        someKindaPend = &QList< AbstractTreeItem * >::append;

        if (start == item2) {
          end = item1;
          someKindaPend = &QList< AbstractTreeItem * >::prepend;
        }

        while (currentIndex < m_sortedItems->size() &&
            m_sortedItems->at(currentIndex) != end) {
          (sortedSubsetOfItems.*someKindaPend)(m_sortedItems->at(currentIndex));
          currentIndex++;
        }

        if (currentIndex >= m_sortedItems->size()) {
          IString msg = "Could not find the second item";
          throw IException(IException::Programmer, msg, _FILEINFO_);
        }

        (sortedSubsetOfItems.*someKindaPend)(end);
      }

      return sortedSubsetOfItems;
    }


    void AbstractTableModel::handleTreeSelectionChanged(
      QList< AbstractTreeItem * > newlySelectedItems,
      AbstractTreeItem::InternalPointerType pointerType) {
      QList< AbstractTreeItem * > interestingSelectedItems;
      foreach (AbstractTreeItem * item, newlySelectedItems) {
        if (item->getPointerType() == pointerType)
          interestingSelectedItems.append(item);
      }

      if (interestingSelectedItems.size()) {
        emit treeSelectionChanged(interestingSelectedItems);
      }
    }


    void AbstractTableModel::sortStatusUpdated() {
      if (m_lessThanFunctor)
        emit sortProgressChanged(m_lessThanFunctor->getCompareCount());
    }


    void AbstractTableModel::sortFinished() {
      bool interrupted = m_lessThanFunctor->interrupted();
      delete m_lessThanFunctor;
      m_lessThanFunctor = NULL;

      if (!interrupted) {
        QList< AbstractTreeItem * > newSortedItems = m_sortingWatcher->result();

        if (!m_dataModel->isFiltering() && !m_dataModel->isRebuilding()) {
          *m_sortedItems = newSortedItems;
          emit modelModified();
        }
      }
      else {
        sort();
      }
    }


    void AbstractTableModel::cancelSort() {
      if (m_lessThanFunctor) {
        m_lessThanFunctor->interrupt();
        m_sortingWatcher->waitForFinished();
      }
    }


    void AbstractTableModel::itemsLost() {
      cancelSort();
      m_sortedItems->clear();
    }


    QList< AbstractTreeItem * > AbstractTableModel::doSort(
      QList< AbstractTreeItem * > itemsToSort) {
      ASSERT(!isSorting());
      if (!isSorting()) {
        setSorting(true);

        QList< TableColumn * > columnsToSortOn = m_columns->getSortingOrder();
        if (sortingOn()) {
          // Reset the timer so that it will begin polling the status of the
          // m_sort.
          m_sortStatusPoller->start(SORT_UPDATE_FREQUENCY);

          // Use n*log2(n) as our estimate of the number of comparisons that it
          // should take to m_sort the list.
          int numItems = itemsToSort.size();
          double a = 1.0;
          double b = 1.0;
          emit sortProgressRangeChanged(0,
              (int)((a * numItems) * (log2(b * numItems))));

          try {
            qStableSort(itemsToSort.begin(), itemsToSort.end(),
                *m_lessThanFunctor);
          }
          catch (SortingCanceledException &e) {
            m_sortStatusPoller->stop();
            emit sortProgressRangeChanged(0, 0);
            emit sortProgressChanged(0);
            emit modelModified();

            setSorting(false);
            return QList< AbstractTreeItem * >();
          }

          // The m_sort is done, so stop emiting status updates and make sure we
          // let the listeners know that the m_sort is done (since the status
          // will not always reach 100% as we are estimating the progress).
          m_sortStatusPoller->stop();
          emit sortProgressRangeChanged(0, 0);
          emit sortProgressChanged(0);
          emit modelModified();
        }

        setSorting(false);
      }

      return itemsToSort;
    }


    void AbstractTableModel::nullify() {
      m_dataModel = NULL;
      m_delegate = NULL;
      m_sortedItems = NULL;
      m_busyItem = NULL;
      m_sortStatusPoller = NULL;
      m_lessThanFunctor = NULL;
      m_columns = NULL;
      m_sortingWatcher = NULL;
    }


    void AbstractTableModel::setSorting(bool isSorting) {
      m_sorting = isSorting;
    }


    void AbstractTableModel::rebuildSort() {
      ASSERT(m_dataModel);
      ASSERT(m_sortedItems);
      m_sortedItems->clear();
      cancelSort();

      if (sortingOn()) {
        m_sortingEnabled = false;
        *m_sortedItems = getItems(0, -1);

        foreach (AbstractTreeItem * item, *m_sortedItems) {
          connect(item, SIGNAL(destroyed(QObject *)), this, SLOT(itemsLost()));
        }

        m_sortingEnabled = true;
        sort();

        emit userWarning(None);
      }
      else {
        cancelSort();
        emit modelModified();

        if (!m_sortingEnabled)
          emit userWarning(SortingDisabled);
        else
          emit userWarning(SortingTableSizeLimitReached);
      }
    }


    // *********** LessThanFunctor implementation *************


    AbstractTableModel::LessThanFunctor::LessThanFunctor(
      TableColumn const *someColumn) : m_column(someColumn) {
      m_sharedData = new LessThanFunctorData;
    }


    AbstractTableModel::LessThanFunctor::LessThanFunctor(
      LessThanFunctor const &other) : m_sharedData(other.m_sharedData) {
      m_column = other.m_column;
    }


    AbstractTableModel::LessThanFunctor::~LessThanFunctor() {
      m_column = NULL;
    }


    int AbstractTableModel::LessThanFunctor::getCompareCount() const {
      return m_sharedData->getCompareCount();
    }


    void AbstractTableModel::LessThanFunctor::interrupt() {
      m_sharedData->setInterrupted(true);
    }


    bool AbstractTableModel::LessThanFunctor::interrupted() {
      return m_sharedData->interrupted();
    }


    void AbstractTableModel::LessThanFunctor::reset() {
      m_sharedData->setInterrupted(false);
    }


    bool AbstractTableModel::LessThanFunctor::operator()(
      AbstractTreeItem *const &left, AbstractTreeItem *const &right) {
      if (left->getPointerType() != right->getPointerType()) {
        IString msg = "Tried to compare apples to oranges";
        throw IException(IException::Programmer, msg, _FILEINFO_);
      }

      if (m_sharedData->interrupted()) {
        throw SortingCanceledException();
      }

      m_sharedData->incrementCompareCount();

      QVariant leftData = left->getData(m_column->getTitle());
      QVariant rightData = right->getData(m_column->getTitle());
      QString busy = BusyLeafItem().getData().toString();

      bool lessThan;
      if (leftData.type() == QVariant::String &&
          rightData.type() == QVariant::String) {
        lessThan = leftData.toString() < rightData.toString();
      }
      else if (leftData.type() == QVariant::Double &&
          rightData.type() == QVariant::Double) {
        lessThan = (leftData.toDouble() < rightData.toDouble());
      }
      else if (leftData.type() == QVariant::Double ||
          rightData.type() == QVariant::Double) {
        // We are comparing a BusyLeafItem to a double. BusyLeafItem's should
        // always be less than the double.
        lessThan = (leftData.toString() == busy);
      }
      else {
        lessThan = leftData.toString() < rightData.toString();
      }

      return lessThan ^ m_column->sortAscending();
    }


    AbstractTableModel::LessThanFunctor &
    AbstractTableModel::LessThanFunctor::operator=(
      LessThanFunctor const &other) {
      if (this != &other) {
        m_column = other.m_column;
        m_sharedData = other.m_sharedData;
      }

      return *this;
    }


    // *********** LessThanFunctorData implementation *************


    AbstractTableModel::LessThanFunctorData::LessThanFunctorData() {
      m_compareCount.fetchAndStoreRelaxed(0);
      m_interruptFlag.fetchAndStoreRelaxed(0);
    }


    AbstractTableModel::LessThanFunctorData::LessThanFunctorData(
      LessThanFunctorData const &other) : QSharedData(other),
      m_compareCount(other.m_compareCount), m_interruptFlag(other.m_interruptFlag) {
    }


    AbstractTableModel::LessThanFunctorData::~LessThanFunctorData() {
    }


    int AbstractTableModel::LessThanFunctorData::getCompareCount() const {
      return m_compareCount;
    }


    void AbstractTableModel::LessThanFunctorData::incrementCompareCount() {
      m_compareCount.fetchAndAddRelaxed(1);
    }


    void AbstractTableModel::LessThanFunctorData::setInterrupted(bool newStatus) {
      newStatus ? m_interruptFlag.fetchAndStoreRelaxed(1) :
      m_interruptFlag.fetchAndStoreRelaxed(0);
    }


    bool AbstractTableModel::LessThanFunctorData::interrupted() {
      return m_interruptFlag != 0;
    }
  }
}