text: // Copyright (c) Microsoft Corporation. All rights reserved.
  // Licensed under the MIT License.
  
  #include <cassert>
  #include "CalculatorHistory.h"
  
  using namespace std;
  using namespace CalculationManager;
  
  CalculatorHistory::CalculatorHistory(size_t maxSize) :
      m_maxHistorySize(maxSize)
  {}
  
  unsigned int CalculatorHistory::AddToHistory(_In_ shared_ptr<CalculatorVector <pair<wstring, int>>> const &tokens, _In_ shared_ptr<CalculatorVector<shared_ptr<IExpressionCommand>>> const &commands, _In_ wstring_view result)
  {
      unsigned int addedIndex;
      wstring generatedExpression;
      shared_ptr<HISTORYITEM> spHistoryItem = make_shared<HISTORYITEM>();
  
      spHistoryItem->historyItemVector.spTokens = tokens;
      spHistoryItem->historyItemVector.spCommands = commands;
  
      // to be changed when pszexp is back
      tokens->GetString(&generatedExpression);
      // Prefixing and suffixing the special Unicode markers to ensure that the expression
      // in the history doesn't get broken for RTL languages
      spHistoryItem->historyItemVector.expression = L'\u202d' + generatedExpression + L'\u202c';
      spHistoryItem->historyItemVector.result = wstring(result);
      addedIndex = AddItem(spHistoryItem);
  
      return addedIndex;
  }
  
  
  unsigned int CalculatorHistory::AddItem(_In_ shared_ptr<HISTORYITEM> const &spHistoryItem)
  {
      if (m_historyItems.size() >= m_maxHistorySize)
      {
          m_historyItems.erase(m_historyItems.begin());
      }
  
      m_historyItems.push_back(spHistoryItem);
      unsigned int lastIndex = static_cast<unsigned>(m_historyItems.size() - 1);
      return lastIndex;
  }
  
  bool CalculatorHistory::RemoveItem(_In_ unsigned int uIdx)
  {
      if (uIdx > m_historyItems.size() - 1)
      {
          return false;
      }
  
      m_historyItems.erase(m_historyItems.begin() + uIdx);
      return true;
  }
  
  vector<shared_ptr<HISTORYITEM>> const& CalculatorHistory::GetHistory()
  {
      return m_historyItems;
  }
  
  shared_ptr<HISTORYITEM> const& CalculatorHistory::GetHistoryItem(_In_ unsigned int uIdx)
  {
      assert(uIdx >= 0 && uIdx < m_historyItems.size());
      return m_historyItems.at(uIdx);
  }
  
  CalculatorHistory::~CalculatorHistory(void)
  {
      ClearHistory();
  }
  
  void CalculatorHistory::ClearHistory()
  {
      m_historyItems.clear();
  }
  