STDVectorStackOverObjectsWithSmartPointers.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include <algorithm>
#include <vector>
 
#include "stacks.h"
#include "STDVectorStack.h"
#include "tarch/Assertions.h"
#include "peano4/grid/GridVertex.h"
#include "peano4/grid/TraversalObserver.h"
#include "peano4/parallel/Node.h"
#include "tarch/logging/Log.h"
#include "tarch/mpi/IntegerMessage.h"
#include "tarch/mpi/Rank.h"
#include "tarch/multicore/Task.h"
 
namespace peano4 {
  namespace stacks {
    template <class T>
    class STDVectorStackOverObjectsWithSmartPointers;
  } // namespace stacks
} // namespace peano4
 
template <class T>
class peano4::stacks::STDVectorStackOverObjectsWithSmartPointers {
private:
  static tarch::logging::Log _log;
 
  std::vector<T>                 _data;
 
  using FlattenedContainer = std::vector<typename T::FlattenedType>;
 
  FlattenedContainer _flattenedData;
 
  IOMode _ioMode;
  int    _ioRank;
  int    _ioTag;
 
#ifdef Parallel
  MPI_Request* _ioMPIRequest;
#endif
 
public:
  STDVectorStackOverObjectsWithSmartPointers();
 
  STDVectorStackOverObjectsWithSmartPointers(const STDVectorStackOverObjectsWithSmartPointers<T>&);
 
  STDVectorStackOverObjectsWithSmartPointers<T>& operator=(const STDVectorStackOverObjectsWithSmartPointers<T>& stack) {
    assertion(stack._data.empty());
    assertion(_data.empty());
  }
 
  void clone(const STDVectorStackOverObjectsWithSmartPointers<T>& data);
 
  class PopBlockStackView {
  protected:
    friend class peano4::stacks::STDVectorStackOverObjectsWithSmartPointers<T>;
 
    std::vector<T> _data;
 
    PopBlockStackView(int numberOfElements, peano4::stacks::STDVectorStackOverObjectsWithSmartPointers<T>* parentStack) {
      const int remainingElements = parentStack->size() - numberOfElements;
 
      _data.insert(
        _data.end(),
        std::make_move_iterator(parentStack->_data.begin() + remainingElements),
        std::make_move_iterator(parentStack->_data.end())
      );
      parentStack->_data.erase(parentStack->_data.begin() + remainingElements, parentStack->_data.end());
    }
 
  public:
    int size() const { return _data.size(); }
 
    const T& get(int index) const {
      assertion2(index >= 0, index, size());
      assertion2(index < size(), index, size());
      return _data[index];
    }
 
    T& get(int index) {
      assertion2(index >= 0, index, size());
      assertion2(index < size(), index, size());
      return _data[index];
    }
 
    std::string toString() const {
      std::ostringstream msg;
      msg << "(size=" << size() << ")";
      return msg.str();
    }
  };
 
  class PushBlockStackView {
  protected:
    friend class peano4::stacks::STDVectorStackOverObjectsWithSmartPointers<T>;
 
    peano4::stacks::STDVectorStackOverObjectsWithSmartPointers<T>* _parentStack;
 
    const int _size;
    const int _baseElement;
 
    PushBlockStackView(int numberOfElements, peano4::stacks::STDVectorStackOverObjectsWithSmartPointers<T>* parentStack):
      _parentStack(parentStack),
      _size(numberOfElements),
      _baseElement(parentStack->_data.size()) {}
 
  public:
    int size() const { return _size; }
 
    T* set(int index, const T& value) {
      assertion2(index >= 0, index, _size);
      assertion2(index < _size, index, _size);
      _parentStack->_data[_baseElement + index] = value;
      return &(_parentStack->_data[_baseElement + index]);
    }
 
    const T& get(int index) const {
      assertion2(index >= 0, index, _size);
      assertion2(index < _size, index, _size);
      return _parentStack->_data[_baseElement + index];
    }
 
    T& get(int index) {
      assertion2(index >= 0, index, _size);
      assertion2(index < _size, index, _size);
      return _parentStack->_data[_baseElement + index];
    }
 
    std::string toString() const {
      std::ostringstream msg;
      msg << "(size=" << _size << ",baseElement=" << _baseElement << ")";
      return msg.str();
    }
  };
 
  T pop();
 
  T& top(int shift = 0);
 
  const T& top(int shift = 0) const;
 
  void push(const T& element);
 
  PopBlockStackView popBlock(int numberOfElements);
 
  PushBlockStackView pushBlock(int numberOfElements);
 
  int size() const;
 
  bool empty() const;
 
  void clear();
 
  void startSend(peano4::grid::TraversalObserver::SendReceiveContext context, int rank, int tag, MPI_Comm comm);
 
  void startReceive(
    peano4::grid::TraversalObserver::SendReceiveContext context, int rank, int tag, MPI_Comm comm, int numberOfElements
  );
 
  bool tryToFinishSendOrReceive();
 
  int sendingOrReceiving() const;
 
  void reverse();
 
  std::string toString() const;
};
 
#include "STDVectorStackOverObjectsWithSmartPointers.cpph"