MaximaItemQueue.h

Go to the documentation of this file.

// -*- mode: c++; c-file-style: "linux"; c-basic-offset: 2; indent-tabs-mode: nil -*-
//
//  Copyright (C) 2026 Gunter Königsmann <wxMaxima@physikbuch.de>
//
//  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 WXM_MAXIMAITEMQUEUE_H
#define WXM_MAXIMAITEMQUEUE_H
 
#include <wx/string.h>
#include <chrono>
#include <cstddef>
#include <deque>
#include <functional>
#include <mutex>
#include <vector>
 
class MaximaItemQueue
{
public:
  struct Item {
    int cause = 0;
    wxString data;
  };
 
  explicit MaximaItemQueue(int mergeableCause,
                           std::size_t backPressureChars = DefaultBackPressureChars)
    : m_mergeableCause(mergeableCause), m_backPressureChars(backPressureChars) {}
 
  bool Push(std::vector<Item> &&items);
 
  bool Take(Item &item);
 
  bool Empty() const;
 
  std::size_t QueuedChars() const;
 
  bool BackPressure() const { return QueuedChars() > m_backPressureChars; }
 
  void Clear();
 
  static constexpr std::size_t DefaultBackPressureChars = 64 * 1024;
 
private:
  const int m_mergeableCause;
  const std::size_t m_backPressureChars;
  mutable std::mutex m_mutex;
  std::deque<Item> m_items;
  std::size_t m_queuedChars = 0;
  bool m_consumerNotified = false;
};
 
enum class DrainResult {
  Empty,
  TimeUp,
  Stopped
};
 
DrainResult DrainForAtMost(
  std::chrono::milliseconds budget,
  const std::function<bool(MaximaItemQueue::Item &)> &take,
  const std::function<bool(const MaximaItemQueue::Item &)> &dispatch);
 
template <class TagMap>
std::size_t SplitIntoItems(const wxString &buffer, const TagMap &knownTags,
                           int textCause,
                           std::vector<MaximaItemQueue::Item> &items,
                           const std::function<bool()> &stopRequested = {}) {
  const std::size_t length = buffer.length();
  wxString text;
  std::size_t pos = 0;
 
  while (pos < length) {
    if (stopRequested && stopRequested())
      break;
    const std::size_t tagPos = buffer.find(wxS('<'), pos);
    if (tagPos == wxString::npos) {
      text.append(buffer, pos, wxString::npos);
      pos = length;
      break;
    }
    if (tagPos > pos) {
      text.append(buffer, pos, tagPos - pos);
      pos = tagPos;
      continue;
    }
 
    auto tag = knownTags.begin();
    bool mayBeTagStart = false;
    for (; tag != knownTags.end(); ++tag) {
      const wxString tagStartName = wxS("<") + tag->first + wxS(">");
      if (buffer.compare(pos, tagStartName.length(), tagStartName) == 0)
        break;
      // The data ends in the middle of this start tag, for example "<mat".
      if ((length - pos < tagStartName.length()) &&
          tagStartName.StartsWith(buffer.substr(pos)))
        mayBeTagStart = true;
    }
    if ((tag == knownTags.end()) && mayBeTagStart)
      // Decide once the rest has arrived. Taking the "<" for text here used
      // to turn the whole tag into text: a line of raw XML in the worksheet.
      break;
    if (tag == knownTags.end()) {
      // A "<" that doesn't start a known tag is just text
      text += buffer[pos];
      pos++;
      continue;
    }
 
    const wxString tagEndName = wxS("</") + tag->first + wxS(">");
    const std::size_t end = buffer.find(tagEndName, pos);
    if (end == wxString::npos)
      // Not complete yet: wait for the rest of it.
      break;
    if (!text.IsEmpty()) {
      items.push_back({textCause, text});
      text.Clear();
    }
    const std::size_t tagFullLength = end + tagEndName.length() - pos;
    items.push_back({static_cast<int>(tag->second), buffer.substr(pos, tagFullLength)});
    pos += tagFullLength;
    if ((pos < length) && (buffer[pos] == wxS('\n')))
      pos++;
  }
 
  if (!text.IsEmpty())
    items.push_back({textCause, std::move(text)});
  return pos;
}
 
#endif // WXM_MAXIMAITEMQUEUE_H