CellList.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2020      Kuba Ober <kuba@bertec.com>
//
//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
//
//  SPDX-License-Identifier: GPL-2.0+
 
#ifndef WXMAXIMA_CELLLIST_H
#define WXMAXIMA_CELLLIST_H
 
#include "CellPtr.h"
#include <memory>
 
class CellListBuilderBase
{
protected:
  std::unique_ptr<Cell> m_head;
  Cell *m_tail = {};
  Cell *m_lastAppended = {};
 
  void base_Append(std::unique_ptr<Cell> &&cells);
 
  Cell *base_DynamicAppend(std::unique_ptr<Cell> &&cells,
                           Cell *(*caster)(Cell *));
 
  void ClearLastAppended() { m_lastAppended = {}; }
};
 
template <typename T = Cell> class CellListBuilder : CellListBuilderBase
{
  static Cell *DynamicCast(Cell *cell) { return dynamic_cast<T *>(cell); }
 
public:
  using CellListBuilderBase::ClearLastAppended;
 
  explicit operator bool() const { return bool(m_head); }
 
  operator std::unique_ptr<T>() && { return TakeHead(); }
 
  T *ReleaseHead()
  {
    T *ptr = dynamic_cast<T *>(m_head.get());
    if (ptr) {
      m_head.release();
      m_tail = {};
      m_lastAppended = {};
    } else
      m_head.reset();
 
    wxASSERT(!m_head && !m_tail && !m_lastAppended); //-V614
    return ptr;
  }
 
  std::unique_ptr<T> TakeHead()
  {
    m_tail = {};
    m_lastAppended = {};
    auto retval = dynamic_unique_ptr_cast<T>(std::move(m_head));
 
    wxASSERT(!m_head && !m_tail && !m_lastAppended);
    return retval;
  }
 
  T *GetTail() const { return dynamic_cast<T*>(m_tail); }
 
  T *GetLastAppended() const { return dynamic_cast<T*>(m_lastAppended); }
 
  // cppcheck-suppress deallocret
  T *Append(T *cells)
  {
    base_Append(std::unique_ptr<Cell>(cells));
    return cells;
  }
 
  T *DynamicAppend(Cell *cells)
  {
    return static_cast<T *>(
        base_DynamicAppend(std::unique_ptr<Cell>(cells), DynamicCast));
  }
 
  T *DynamicAppend(std::unique_ptr<Cell> &&cells)
  {
    return static_cast<T *>(base_DynamicAppend(std::move(cells), DynamicCast));
  }
 
  T *Append(std::unique_ptr<T> &&cells)
  {
    auto *const retval = cells.get();
    base_Append(std::move(cells));
    return retval;
  }
};
 
class CellList
{
public:
 
  static void Check(const Cell *cell);
  static void Check(const GroupCell *cell);
 
  static std::unique_ptr<Cell> SetNext(Cell *cell, std::unique_ptr<Cell> &&next);
 
  static void DeleteList(Cell *afterMe);
 
  static void AppendCell(Cell *cell, std::unique_ptr<Cell> &&tail);
 
  template <typename T>
  static void AppendCell(const std::unique_ptr<T> &cell, std::unique_ptr<Cell> &&tail)
  { AppendCell(cell.get(), std::move(tail)); }
 
  struct SplicedIn
  {
    Cell *lastSpliced;
  };
 
  static SplicedIn SpliceInAfter(Cell *where, std::unique_ptr<Cell> &&head, Cell *last = nullptr);
 
  struct TornOut {
    CellPtr<Cell> cell;
    std::unique_ptr<Cell> cellOwner;
    std::unique_ptr<Cell> tailOwner;
  };
 
  static TornOut TearOut(Cell *first, Cell *last);
};
 
#endif