PcmSinkBufferEnqueueResult.hpp

#ifndef ZAO_ENDPOINT_AUDIO_PCM_SINK_BUFFER_ENQUEUE_RESULT_HPP_
#define ZAO_ENDPOINT_AUDIO_PCM_SINK_BUFFER_ENQUEUE_RESULT_HPP_
 
namespace zao {
namespace endpoint {
namespace audio {
 
class PcmSinkBufferEnqueueResult {
 public:
  enum class ErrorType {
    kNone,
 
    kAborted,
 
    kInvalidBuffer,
  };
 
 public:
  PcmSinkBufferEnqueueResult(ErrorType error) noexcept : error_(error) {}
 
  PcmSinkBufferEnqueueResult(const PcmSinkBufferEnqueueResult&) = delete;
 
  PcmSinkBufferEnqueueResult& operator=(const PcmSinkBufferEnqueueResult&) =
      delete;
 
  PcmSinkBufferEnqueueResult(PcmSinkBufferEnqueueResult&& other) noexcept =
      default;
 
  PcmSinkBufferEnqueueResult& operator=(
      PcmSinkBufferEnqueueResult&& other) noexcept = default;
 
  bool HasError() const noexcept { return error_ != ErrorType::kNone; }
 
  bool HasAbortedError() const noexcept {
    return error_ == ErrorType::kAborted;
  }
 
  bool HasInvalidBufferError() const noexcept {
    return error_ == ErrorType::kInvalidBuffer;
  }
 
  const char* What() const noexcept {
    switch (error_) {
      case ErrorType::kNone:
        return "No error.";
      case ErrorType::kAborted:
        return "Aborted by FlushQueue.";
      case ErrorType::kInvalidBuffer:
        return "Invalid buffer.";
      default:
        return "Unknown error.";
    }
  }
 
 private:
  ErrorType error_ = ErrorType::kNone;
};
 
}  // namespace audio
}  // namespace endpoint
}  // namespace zao
 
#endif  // ZAO_ENDPOINT_AUDIO_PCM_SINK_BUFFER_ENQUEUE_RESULT_HPP_