uart.h

// Copyright 2023 The Pigweed Authors
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
// use this file except in compliance with the License. You may obtain a copy of
// the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations under
// the License.
 
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <optional>
 
#include "pw_assert/assert.h"
#include "pw_bytes/span.h"
#include "pw_chrono/system_clock.h"
#include "pw_status/status.h"
#include "pw_status/status_with_size.h"
#include "pw_uart/uart_base.h"
 
namespace pw::uart {
 
 
class Uart : public UartBase {
 public:
  ~Uart() override = default;
 
  StatusWithSize ReadAtLeast(ByteSpan rx_buffer, size_t min_bytes) {
    return DoTryReadFor(rx_buffer, min_bytes, std::nullopt);
  }
 
  StatusWithSize ReadExactly(ByteSpan rx_buffer) {
    return DoTryReadFor(rx_buffer, rx_buffer.size(), std::nullopt);
  }
 
  // TODO: https://pwbug.dev/368149122 - Remove after transition
  Status Read(ByteSpan rx_buffer) {
    return DoTryReadFor(rx_buffer, std::nullopt).status();
  }
 
  StatusWithSize TryReadAtLeastFor(ByteSpan rx_buffer,
                                   size_t min_bytes,
                                   chrono::SystemClock::duration timeout) {
    return DoTryReadFor(rx_buffer, min_bytes, timeout);
  }
 
  StatusWithSize TryReadExactlyFor(ByteSpan rx_buffer,
                                   chrono::SystemClock::duration timeout) {
    return DoTryReadFor(rx_buffer, rx_buffer.size(), timeout);
  }
 
  StatusWithSize TryReadFor(ByteSpan rx_buffer,
                            chrono::SystemClock::duration timeout) {
    // TODO: https://pwbug.dev/368149122 - Remove after transition
    return DoTryReadFor(rx_buffer, timeout);
  }
 
  Status Write(ConstByteSpan tx_buffer) {
    return DoTryWriteFor(tx_buffer, std::nullopt).status();
  }
 
  StatusWithSize TryWriteFor(ConstByteSpan tx_buffer,
                             chrono::SystemClock::duration timeout) {
    return DoTryWriteFor(tx_buffer, timeout);
  }
 
  Status FlushOutput() { return DoFlushOutput(); }
 
 private:
  // TODO: https://pwbug.dev/368149122 - Remove after transition.
  virtual StatusWithSize DoTryReadFor(
      ByteSpan rx_buffer,
      std::optional<chrono::SystemClock::duration> timeout) {
    return DoTryReadFor(rx_buffer, rx_buffer.size(), timeout);
  }
 
  // TODO: https://pwbug.dev/368149122 - Make pure virtual after transition.
  virtual StatusWithSize DoTryReadFor(
      ByteSpan /*rx_buffer*/,
      size_t /*min_bytes*/,
      std::optional<chrono::SystemClock::duration> /*timeout*/) {
    return StatusWithSize::Unimplemented();
  }
 
  virtual StatusWithSize DoTryWriteFor(
      ConstByteSpan tx_buffer,
      std::optional<chrono::SystemClock::duration> timeout) = 0;
  virtual Status DoFlushOutput() = 0;
};
 
}  // namespace pw::uart