h4_packet.h

// Copyright 2024 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 <cstdint>
 
#include "lib/stdcompat/utility.h"
#include "pw_bluetooth/hci_h4.emb.h"
#include "pw_function/function.h"
#include "pw_span/span.h"
 
namespace pw::bluetooth::proxy {
 
 
class H4PacketInterface {
 public:
  H4PacketInterface() = default;
 
  H4PacketInterface(const H4PacketInterface& other) = delete;
 
  H4PacketInterface(H4PacketInterface&& other) = default;
  H4PacketInterface& operator=(H4PacketInterface&& other) = default;
 
  virtual ~H4PacketInterface() = default;
 
  virtual emboss::H4PacketType GetH4Type() const = 0;
 
  virtual void SetH4Type(emboss::H4PacketType) = 0;
 
  pw::span<uint8_t> GetHciSpan() { return DoGetHciSpan(); }
  pw::span<const uint8_t> GetHciSpan() const { return DoGetHciSpan(); }
 
 protected:
  H4PacketInterface& operator=(const H4PacketInterface& other) = default;
 
  static constexpr std::uint8_t kH4PacketIndicatorSize = 1;
 
 private:
  virtual pw::span<uint8_t> DoGetHciSpan() const = 0;
};
 
class H4PacketWithHci final : public H4PacketInterface {
 public:
  H4PacketWithHci(emboss::H4PacketType h4_type, pw::span<uint8_t> hci_span)
      : hci_span_(hci_span), h4_type_(h4_type) {}
 
  H4PacketWithHci(pw::span<uint8_t> h4_span)
      : hci_span_(h4_span.subspan(kH4PacketIndicatorSize)),
        h4_type_(emboss::H4PacketType{h4_span[0]}) {}
 
  H4PacketWithHci(const H4PacketWithHci& other) = delete;
 
  H4PacketWithHci(H4PacketWithHci&& other) = default;
  H4PacketWithHci& operator=(H4PacketWithHci&& other) = default;
 
  ~H4PacketWithHci() final = default;
 
  emboss::H4PacketType GetH4Type() const final { return h4_type_; }
 
  void SetH4Type(emboss::H4PacketType h4_type) final { h4_type_ = h4_type; }
 
 private:
  H4PacketWithHci& operator=(const H4PacketWithHci& other) = default;
 
  pw::span<uint8_t> hci_span_;
 
  emboss::H4PacketType h4_type_;
 
  pw::span<uint8_t> DoGetHciSpan() const final { return hci_span_; }
};
 
class H4PacketWithH4 final : public H4PacketInterface {
 public:
  using ReleaseFn = Function<void(const uint8_t*)>;
 
  H4PacketWithH4() = default;
  H4PacketWithH4(pw::span<uint8_t> h4_span) : h4_span_(h4_span) {}
 
  H4PacketWithH4(pw::span<uint8_t> h4_span, ReleaseFn&& release_fn)
      : h4_span_(h4_span), release_fn_(std::move(release_fn)) {}
 
  H4PacketWithH4(emboss::H4PacketType h4_type, pw::span<uint8_t> h4_span)
      : H4PacketWithH4(h4_span) {
    SetH4Type(h4_type);
  }
 
  H4PacketWithH4(const H4PacketWithH4& other) = delete;
  H4PacketWithH4& operator=(const H4PacketWithH4& other) = delete;
 
  H4PacketWithH4(H4PacketWithH4&& other)
      : h4_span_(other.h4_span_), release_fn_(std::move(other.release_fn_)) {
    other.Reset();
  }
 
  H4PacketWithH4& operator=(H4PacketWithH4&& other) {
    h4_span_ = other.h4_span_;
    release_fn_ = std::move(other.release_fn_);
    other.Reset();
    return *this;
  }
 
  ~H4PacketWithH4() final {
    if (release_fn_) {
      release_fn_(h4_span_.data());
    }
  }
 
  emboss::H4PacketType GetH4Type() const final {
    if (h4_span_.empty()) {
      return emboss::H4PacketType::UNKNOWN;
    }
 
    return emboss::H4PacketType(h4_span_[0]);
  }
 
  void SetH4Type(emboss::H4PacketType h4_type) final {
    if (!h4_span_.empty()) {
      h4_span_.data()[0] = cpp23::to_underlying(h4_type);
    }
  }
 
  bool HasReleaseFn() {
    // pw::Function bool returns true if not-empty
    return bool{release_fn_};
  }
 
  // Returns the release function (which could be empty) and resets the packet.
  // Essentially it moves ownership of the buffer to the caller (who should have
  // already stored `GetH4Span()` since packet's span will be reset by this
  // call).
  ReleaseFn ResetAndReturnReleaseFn() {
    ReleaseFn fn = std::move(release_fn_);
    Reset();
    return fn;
  }
 
  pw::span<uint8_t> GetH4Span() {
    if (h4_span_.empty()) {
      return {};
    }
    return h4_span_;
  }
 
 private:
  void Reset() {
    h4_span_ = pw::span<uint8_t>();
    release_fn_ = nullptr;
  }
 
  pw::span<uint8_t> h4_span_;
 
  ReleaseFn release_fn_{};
 
  pw::span<uint8_t> DoGetHciSpan() const final {
    // If h4_span is empty, then return an empty span for hci also.
    if (h4_span_.empty()) {
      return {};
    }
    return pw::span(h4_span_.data() + kH4PacketIndicatorSize,
                    h4_span_.size() - kH4PacketIndicatorSize);
  }
};
 
}  // namespace pw::bluetooth::proxy