PcmBufferReader.hpp

#ifndef ZEP_AUDIO_PCM_BUFFER_READER_HPP_
#define ZEP_AUDIO_PCM_BUFFER_READER_HPP_

#include <cstddef>
#include <cstdint>
#include <memory>

#include "../TimestampInterface.hpp"

namespace zep {
namespace audio {

class PcmBufferPoolInterface;

class PcmBufferReader final {
 public:
  PcmBufferReader() noexcept {}

  PcmBufferReader(const std::weak_ptr<PcmBufferPoolInterface>& pool_weak,
                  std::int16_t* pointer, std::size_t readable_samples,
                  TimestampInterface::Rep head_timestamp) noexcept
      : pool_weak_(pool_weak),
        pointer_(pointer),
        readable_samples_(readable_samples),
        head_timestamp_(head_timestamp) {}

  PcmBufferReader(PcmBufferReader&& other) noexcept {
    *this = std::move(other);
  }

  PcmBufferReader& operator=(PcmBufferReader&& other) noexcept {
    Finalize();
    std::swap(pool_weak_, other.pool_weak_);
    std::swap(pointer_, other.pointer_);
    std::swap(readable_samples_, other.readable_samples_);
    std::swap(head_timestamp_, other.head_timestamp_);
    return *this;
  }

  // コピー構築禁止
  PcmBufferReader(const PcmBufferReader&) = delete;

  // コピー代入禁止
  PcmBufferReader& operator=(const PcmBufferReader&) = delete;

  ~PcmBufferReader() noexcept { Finalize(); }

  bool IsValid() const noexcept { return !!pointer_; }

  explicit operator bool() const noexcept { return IsValid(); }

  const std::int16_t* GetPointer() const noexcept { return pointer_; }

  std::size_t GetReadableSamples() const noexcept { return readable_samples_; }

  TimestampInterface::Rep GetHeadTimestamp() const noexcept {
    return head_timestamp_;
  }

  inline void Finalize() noexcept;

 private:
  std::weak_ptr<PcmBufferPoolInterface> pool_weak_;
  const std::int16_t* pointer_ = nullptr;
  std::size_t readable_samples_ = 0;
  TimestampInterface::Rep head_timestamp_ = 0;
};

}  // namespace audio
}  // namespace zep

#include "PcmBufferPoolInterface.hpp"

inline void zep::audio::PcmBufferReader::Finalize() noexcept {
  if (!pointer_) {
    return;
  }
  if (auto pool = pool_weak_.lock()) {
    pool->FinalizeReader(*this);
  }
  pool_weak_.reset();
  pointer_ = nullptr;
  readable_samples_ = 0;
  head_timestamp_ = 0;
}

#endif  // ZEP_AUDIO_PCM_BUFFER_READER_HPP_