text: /*
   * Distributed under the OSI-approved Apache License, Version 2.0.  See
   * accompanying file Copyright.txt for details.
   *
   * BP3Reader.h
   *
   *  Created on: Feb 27, 2017
   *      Author: William F Godoy godoywf@ornl.gov
   */
  
  #ifndef ADIOS2_ENGINE_BP3_BP3READER_H_
  #define ADIOS2_ENGINE_BP3_BP3READER_H_
  
  #include "adios2/common/ADIOSConfig.h"
  #include "adios2/core/Engine.h"
  #include "adios2/helper/adiosComm.h"
  #include "adios2/toolkit/format/bp/bp3/BP3Deserializer.h"
  #include "adios2/toolkit/transportman/TransportMan.h"
  
  namespace adios2
  {
  namespace core
  {
  namespace engine
  {
  
  class BP3Reader : public Engine
  {
  
  public:
      /**
       * Unique constructor
       * @param io
       * @param name
       * @param openMode only read
       * @param comm
       */
      BP3Reader(IO &io, const std::string &name, const Mode mode,
                helper::Comm comm);
  
      ~BP3Reader() = default;
  
      StepStatus BeginStep(StepMode mode = StepMode::Read,
                           const float timeoutSeconds = -1.0) final;
  
      size_t CurrentStep() const final;
  
      void EndStep() final;
  
      void PerformGets() final;
  
  private:
      format::BP3Deserializer m_BP3Deserializer;
      transportman::TransportMan m_FileManager;
      transportman::TransportMan m_SubFileManager;
  
      /** used for per-step reads, TODO: to be moved to BP3Deserializer */
      size_t m_CurrentStep = 0;
      bool m_FirstStep = true;
  
      void Init();
      void InitTransports();
      void InitBuffer();
  
  #define declare_type(T)                                                        \
      void DoGetSync(Variable<T> &, T *) final;                                  \
      void DoGetDeferred(Variable<T> &, T *) final;
      ADIOS2_FOREACH_STDTYPE_1ARG(declare_type)
  #undef declare_type
  
      void DoClose(const int transportIndex = -1) final;
  
      template <class T>
      void GetSyncCommon(Variable<T> &variable, T *data);
  
      template <class T>
      void GetDeferredCommon(Variable<T> &variable, T *data);
  
      template <class T>
      void ReadVariableBlocks(Variable<T> &variable);
  
  #define declare_type(T)                                                        \
      std::map<size_t, std::vector<typename Variable<T>::BPInfo>>                \
      DoAllStepsBlocksInfo(const Variable<T> &) const final;                     \
                                                                                 \
      std::vector<std::vector<typename Variable<T>::BPInfo>>                     \
      DoAllRelativeStepsBlocksInfo(const Variable<T> &) const final;             \
                                                                                 \
      std::vector<typename Variable<T>::BPInfo> DoBlocksInfo(                    \
          const Variable<T> &variable, const size_t step) const final;
  
      ADIOS2_FOREACH_STDTYPE_1ARG(declare_type)
  #undef declare_type
  
      size_t DoSteps() const final;
  };
  
  } // end namespace engine
  } // end namespace core
  } // end namespace adios2
  
  #endif /* ADIOS2_ENGINE_BP3_BP3READER_H_ */
  