mlListBase.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_LIST_BASE_H
#define ML_LIST_BASE_H
 

 
// Defines the following classes:
// - ListBase: An abstract class derived from Base providing methods available
//     for all list classes.
// - ListTemplate:  A class template derived from ListBase and std::vector.
//     It implements the persistence functionality of a list.
// - BaseListTemplate: A class template derived from ListTemplate. It should be
//     used for item classes that are subclasses of BaseItem.
// - For class BaseItem see mlBaseItem.h.
 
// ML-includes
#include "mlBaseInit.h"
#include "mlModuleIncludes.h"
#include "mlTreeNode.h"
#include "mlStringConversion.h"
 
 
 
#include "mlListParser.h"
 
// Also include BaseItem although it is not needed here; however many derived classes still expect it.
#include "mlBaseItem.h"
 
// Safe casts.
#include "mlRangeCasts.h"
 
#include <algorithm>
 
ML_START_NAMESPACE
 
class BaseItem;
class ListContainerBase;
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------

class MLBASEEXPORT ListBase : public Base
{
public:

  ListBase (bool persistence)
    : _hasPersistence(persistence),
      _actionClass(ActNew),
      _actionId(-1),
      _actionIndex(-1),
      _currentIndex(-1), 
      _container(nullptr)
  {}
 
  ListBase(const ListBase& other)
    : _hasPersistence(other.hasPersistence()),
    _actionClass(other.getActionClass()),
    _actionId(other.getActionId()),
    _actionIndex(other.getActionIndex()),
    _currentIndex(other.getCurrentIndex()), 
    _container(nullptr)
  {}


  virtual size_t getSize () const = 0;

  virtual BaseItem* getItemAt(MLssize_t /*index*/) { return nullptr; };

  virtual const BaseItem* getConstItemAt(MLssize_t /*index*/) const { return nullptr; };

  virtual void insertItemAt(MLssize_t /*index*/, const BaseItem* /*item*/) {};

  virtual void modifyItemAt(MLssize_t /*index*/, const BaseItem* /*item*/) {};

  virtual void deleteItemAt(MLssize_t /*index*/) {};

  virtual void selectItemAt(MLssize_t /*index*/) {};

  virtual const RuntimeType* getItemTypeId() const { return nullptr; };

  virtual void clearList ()
  { setAction(ActNew); }

  virtual ListBase* clone() const { return nullptr; };

  ListBase* deepCopy() const override { return clone(); };

 
  void setContainer(ListContainerBase* container) { _container = container; }
  ListContainerBase* getContainer() const { return _container; }


  virtual bool hasPersistence() const {  return _hasPersistence; }

  virtual void setPersistence(bool persistence) { _hasPersistence = persistence; }

  [[deprecated("Use hasPersistence() instead.")]]
  bool hasPersistance () const { return hasPersistence(); }
  [[deprecated("Use setPersistence(bool persistence) instead.")]]
  void setPersistance (bool persistence) { setPersistence(persistence); }

  MLBASEEXPORT friend std::ostream& operator << (std::ostream &s, const ListBase &list);

  void addStateToTree(TreeNode* parent) const override;

  ML_SET_ADDSTATE_VERSION(0);

  void readStateFromTree(TreeNode* parent) override;

 


  enum ActionClass
       {
         ActNone = 0,        
         ActUnknown,         
         ActNew,             
         ActSelect,          
         ActModify,          
         ActDelete,          
         ActInsert,          
         ActInsertOvw,       
         ActNumActions       
       };

  static const char *const ActionClassNames[ActNumActions];

  virtual void setAction (ActionClass actionClass, MLssize_t id, MLssize_t index);

  virtual void setAction (ActionClass actionClass)
  { setAction(actionClass, -1, -1); }

  virtual void getAction (ActionClass &actionClass, MLssize_t &id, MLssize_t &index) const;

  virtual ActionClass getActionClass () const
  { return _actionClass; }

  virtual MLssize_t getActionId () const
  { return _actionId; }

  virtual MLssize_t getActionIndex () const
  { return _actionIndex; }

  virtual MLssize_t getCurrentIndex () const
  { return _currentIndex; }

  virtual bool isModified () const
  { return (ActSelect != _actionClass && ActNone != _actionClass); }
 

 
 
protected:

  char *newString (const std::string &str) const
  { return ParserBase::newString(str); }

  void deleteString (char *str) const
  { ParserBase::deleteString(str); }

  ListBase &operator = (const ListBase &list);
 
private:

  bool _hasPersistence;

  ActionClass _actionClass;

  MLssize_t _actionId;

  MLssize_t _actionIndex;

  MLssize_t _currentIndex;
 
  ListContainerBase* _container;
 
  ML_ABSTRACT_CLASS_HEADER(ListBase)
 
};
 
 
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------

template <class T>
class ListTemplate : public ListBase, public std::vector<T>
{
public:

  typedef T itemType;
 


  ListTemplate () : ListBase(false) {}

  ListTemplate (bool persistence) : ListBase(persistence) {}
 
  ListTemplate(const ListTemplate& other) : ListBase(other), std::vector<T>(other) {}

 


  size_t getSize () const override
  { using namespace std; return vector<T>::size(); }

  void clearList () override
  { ListBase::clearList(); using namespace std; vector<T>::clear(); }
 

  ListTemplate<T> &operator = (const ListTemplate<T> &list)
  {
    using namespace std;
 
    ListBase::operator =(list);
    vector<T>::operator =(list);
 
    return *this;
  }

  ListTemplate<T>* clone() const override;

  ListTemplate<T>* deepCopy() const override { return clone(); };

 

  std::string persistentState() const override;

  void setPersistentState(const std::string&  state) override;
 
 
public:

  void addStateToTree(TreeNode* parent) const override;

  ML_SET_ADDSTATE_VERSION(2);

  void readStateFromTree(TreeNode* parent) override;

 
protected:


  virtual std::string itemState([[maybe_unused]] typename ListTemplate<T>::const_iterator it) const
  {
    return {};
  }

  virtual void setItemState(typename ListTemplate<T>::iterator /*it*/, const std::string& /*state*/) {}
};
 
 
 
// ------------------------------------------------------------------
// Implementation of ListTemplate
// ------------------------------------------------------------------
 
template <class T>
std::string ListTemplate<T>::persistentState() const
{
  std::string listStr;
 
  using namespace std;
 
  if (hasPersistence())
  {
    // Start list with an opening bracket
    listStr = "[";
 
    // Iterate through list
    for (auto it = vector<T>::begin(); it != vector<T>::end(); ++it)
    {
      // Separate items by a comma
      if (it != vector<T>::begin()) {
        listStr += ", ";
      }
 
      // Get string representation for item object
      auto itemStr = itemState(it);
      if (!itemStr.empty())
      {
        if (ListParser::needsQuote(itemStr))
        {
          listStr += ListParser::quoteString(itemStr);
        }
        else {
          listStr += itemStr;
        }
      }
      else
        // Empty item string, add "" to list string
        listStr += "\"\"";
    }
 
    // End list with a closing bracket
    listStr += ']';
  }
 
  return listStr;
}
 
template <class T> void ListTemplate<T>::setPersistentState(const std::string &state)
{
  using namespace std;
 
  if (hasPersistence())
  {
    ListParser parser;
 
    // Start with empty list
    clearList();
 
    // Initialize parser
    auto parserResult = parser.init(state.c_str());
 
    while (!parserResult)
    {
      // Parse next item string
      std::string itemString;
      std::tie(parserResult, itemString) = parser.nextItem();
      if (!itemString.empty() && parserResult != ListParser::kEndOfSource)
      {
        // Append new item object at end of list
        vector<T>::insert(vector<T>::end(), T());
 
        // Restore item object from item string
        setItemState(vector<T>::end() - 1, itemString);
      }
    }
 
    // Set list action
    setAction(ListBase::ActNew);
 
    // Print error message to console
    if (parserResult > 0 && parserResult != ParserBase::kEmptyString) {
      ML_PRINT_ERROR("ListTemplate::setPersistentState()", ML_EMPTY_MESSAGE,
        parser.getErrorMessage(parserResult));
    }
  }
}
 

template <class T>
void ListTemplate<T>::addStateToTree(TreeNode* parent) const
{
  using namespace std;
 
  //if (!hasPersistence()) return;
 
  ML_ADDSTATE_VERSION(ListTemplate<T>);
 
  // add listbase members
  ML_ADDSTATE_SUPER(ListBase);
 
  // write list size always as unsigned 64 bit integer.
  parent->addChild(static_cast<MLuint64>(vector<T>::size()), "ListSize");
 
  // write list items:
  TreeNode* items = parent->addChild("ListItems");
 
  // Iterate through list
  for (auto it = vector<T>::cbegin(); it != vector<T>::cend(); ++it)
  {
    auto state = itemState(it);
    items->addChild(state, "Item");
  }
 
}

template <class T>
void ListTemplate<T>::readStateFromTree(TreeNode* parent)
{
  using namespace std;
 
  if (!hasPersistence()) { return; }
 
  int version = parent->getVersion("ListTemplate");
 
  // Currently supporting version <= 2 only, version 2 is saved by 64 bit systems.
  if (version > 2){
    // Error, too high version number.
    throw TreeNodeException(TNE_UnsupportedClassVersion);
  }
 
  if (version >= 1) {
    // ListBase saves its members since version 1:
    ML_READSTATE_SUPER(ListBase);
  }
 
  bool endLoop = false;
 
  clearList();
 
  // read size if possible
  MLuint64 loadedSize = 0;
  ML_READCHILD_OPTIONAL(loadedSize, "ListSize", 0);
 
  // reserve some memory for the list. However, we do really want to rely on the ListSize
  // setting and still read until a child is not found.
  vector<T>::reserve( loadedSize );
 
  TreeNode* items = parent->readContainerChild("ListItems");
 
  std::string currStr;
  do {
    // try to read next child:
    if (items->hasChild()) {
      items->readChild(currStr);
    } else {
      // break free from loop
      endLoop = true;
    }
    if (!endLoop) {
 
      vector<T>::insert(vector<T>::end(), T());
 
      // Restore item object from item string
      setItemState(vector<T>::end()-1, currStr);
 
      currStr = {};
    }
  } while (!endLoop);
 
  // Set list action
  setAction(ListBase::ActNew);
}
 
 

template <class T>
ListTemplate<T>* ListTemplate<T>::clone() const
{
  // get runtime type of this instance
  const RuntimeType* thisType = this->getTypeId();
 
  // valid type?
  if (!thisType || !thisType->canCreateInstance()) {
    // invalid type
    return nullptr;
  }
 
  ListTemplate<T>* newList = static_cast<ListTemplate<T>*>(thisType->createInstance());
  if (!newList) {
    // object creation failed
    return nullptr;
  }
 
  (*newList) = (*this);
 
  return newList;
}
 
 
 
 
 
// ------------------------------------------------------------------
// ------------------------------------------------------------------

template <class T>
class BaseListTemplate : public ListTemplate<T>
{
public:


  BaseListTemplate () : ListTemplate<T>(), _nextId(1) {}

  BaseListTemplate (bool persistence) : ListTemplate<T>(persistence), _nextId(1) {}
 
  BaseListTemplate(const BaseListTemplate& other) : ListTemplate<T>(other), _nextId(other._nextId) {}


  BaseListTemplate<T>& operator=(const BaseListTemplate& other) = default;

  BaseItem* getItemAt(MLssize_t index) override{
    return &(*this)[mlrange_cast<size_t>(index)];
  };

  const BaseItem* getConstItemAt(MLssize_t index) const override {
    return &(*this)[mlrange_cast<size_t>(index)];
  };

  void insertItemAt(MLssize_t index, const BaseItem* item) override {
    if (item && (getItemTypeId() == item->getTypeId())) {
      doInsertItem(index, *static_cast<const T*>(item) );
    }
  };
 

  void modifyItemAt(MLssize_t index, const BaseItem* item) override {
    if (item && (getItemTypeId() == item->getTypeId())) {
      doModifyItem(index, *static_cast<const T*>(item) );
    }
  };

  void deleteItemAt(MLssize_t index) override {
    doDeleteItem(index);
  };

  void selectItemAt(MLssize_t index) override {
    doSelectItem(index);
  };

  const RuntimeType* getItemTypeId() const override {
    return T::getClassTypeId();
  }
 


  virtual MLssize_t newId () { return _nextId++; }

  virtual void usedId (MLssize_t id)
  {
      if (id >= _nextId) {
        _nextId = id+1;
      }
  }

  virtual void resetId ()
  {
    _nextId = 1;
    for (typename ListTemplate<T>::iterator it = ListTemplate<T>::begin(); it != ListTemplate<T>::end(); it++){
      usedId(it->getId());
    }
  }


  void clearList () override
  {
    ListTemplate<T>::clear();
    resetId();
  }
 


  virtual void doDeleteItem (MLssize_t index);

  virtual void doInsertItem (MLssize_t index, const T &item);

  virtual void doModifyItem (MLssize_t index, const T &item);

  virtual void doSelectItem (MLssize_t index);

  virtual void appendItem(const T &item);

  void addStateToTree(TreeNode* parent) const override;


  ML_SET_ADDSTATE_VERSION(1);

  void readStateFromTree(TreeNode* parent) override;
 
 

 
 
protected:

  std::string itemState(typename ListTemplate<T>::const_iterator it) const override
  {
    return it->persistentState();
  }

  void setItemState(typename ListTemplate<T>::iterator it, const std::string& state) override
  {
    it->setPersistentState(state);
    usedId(it->getId());
  }
 
private:

  MLssize_t _nextId;
 
};
 
 
 
 
// ------------------------------------------------------------------
// --- Implementation of BaseListTemplate
// ------------------------------------------------------------------

template <class T>
void BaseListTemplate<T>::doDeleteItem (MLssize_t index)
{
  if ((index >= 0) && (index < static_cast<MLssize_t>(ListTemplate<T>::size())) )
  {
    this->setAction(ListTemplate<T>::ActDelete, (*this)[mlrange_cast<size_t>(index)].getId(), index);
    ListTemplate<T>::erase(ListTemplate<T>::begin()+index);
  }
}
 

template <class T>
void BaseListTemplate<T>::doInsertItem (MLssize_t index, const T &item)
{
  MLssize_t id=0;
 
  if ((index >= 0) && (index <= mlrange_cast<MLssize_t>(ListTemplate<T>::size())) )
  {
    ListTemplate<T>::insert(ListTemplate<T>::begin()+index, item);
    id = newId();
    (*this)[static_cast<size_t>(index)].setId(id);
    this->setAction(ListTemplate<T>::ActInsert, id, index);
  }
}

template <class T>
void BaseListTemplate<T>::appendItem(const T &item)
{
    doInsertItem(static_cast<MLssize_t>(ListTemplate<T>::size()), item);
}
 

template <class T>
void BaseListTemplate<T>::doModifyItem (MLssize_t index, const T &item)
{
  if ((index >= 0) && (index < mlrange_cast<MLssize_t>(ListTemplate<T>::size())) )
  {
    const size_t idx_size_t = static_cast<size_t>(index);
    const MLssize_t id = (*this)[idx_size_t].getId();
    (*this)[idx_size_t] = item;
    (*this)[idx_size_t].setId(id);
    this->setAction(ListTemplate<T>::ActModify, id, index);
  }
}
 

template <class T>
void BaseListTemplate<T>::doSelectItem (MLssize_t index)
{
  if ((index >= 0) && (index < mlrange_cast<MLssize_t>(ListTemplate<T>::size())) )
  {
    this->setAction(ListTemplate<T>::ActSelect, (*this)[static_cast<size_t>(index)].getId(), index);
  }
  else if (index == -1)
  {
    // deselect all
    this->setAction(ListTemplate<T>::ActSelect);
  }
}
 

template <class T>
void BaseListTemplate<T>::addStateToTree(TreeNode* parent) const
{
  ML_ADDSTATE_VERSION(BaseListTemplate<T>);
 
  // add ListBase members
  ML_ADDSTATE_SUPER(ListBase);
 
  typename BaseListTemplate<T>::const_iterator it;
  MLuint64 i = 0;
 
  // write list size
  parent->addChild(static_cast<MLuint64>(ListTemplate<T>::size()), "ListSize");
 
  TreeNode* items = parent->addChild("ListItems");
 
  // Iterate through list
  for (it = ListTemplate<T>::begin(); it != ListTemplate<T>::end(); it++, i++)
  {
    items->addChild(&(*it), "Item", false);
  }
 
}

template <class T>
void BaseListTemplate<T>::readStateFromTree(TreeNode* parent)
{
  int version = parent->getVersion("BaseListTemplate");
 
  // Currently supporting version <= 2 only, version 2 is 64 bit version.
  if (version > 2) {
    throw TreeNodeException(TNE_UnsupportedClassVersion);
  }
 
  if (version >= 1) {
    // ListBase saves its members since version 1:
    ML_READSTATE_SUPER(ListBase);
  }
 
  bool endLoop = false;
 
  clearList(); // includes _nextId = 1;
 
  // read size if possible
  MLuint64 loadedSize = 0;
  ML_READCHILD_OPTIONAL(loadedSize, "ListSize", 0);
 
  // reserve some memory for the list. However, we do not really want to rely on the ListSize
  // setting and still read until a child is not found.
  ListTemplate<T>::reserve( loadedSize );
 
  TreeNode* items = parent->readContainerChild("ListItems");
 
  if (items) do {
    // try to read next child:
    if (items->hasChild()) {
      ListTemplate<T>::insert(ListTemplate<T>::end(), T());
      items->readChild(*(ListTemplate<T>::end()-1));
    } else {
      // break free from loop
      endLoop = true;
    }
    if (ListTemplate<T>::size() > 0){
        // update _nextId:
        _nextId = std::max(_nextId, (ListTemplate<T>::end()-1)->getId() + 1);
    } else {
        endLoop = true;
    }
  } while (!endLoop);
 
  // Set list action
  this->setAction(ListTemplate<T>::ActNew);
}
 
 
ML_END_NAMESPACE
 
 
#endif