Consider a hal::stream::drain()

[kammce]

It takes an address to a length of a payload and loads the data into buffer used on it like so.

drain_into_buffer.set_length(parse_length.value());
input | get_header | parse_crc | parse_length | drain_into_buffer(p_some_buffer);

class drain
{
public:
  constexpr explicit drain(const size_t& p_bytes_to_drain)
    : m_bytes_to_drain(&p_bytes_to_drain)
  {}

  /**
   * @brief Update the sink to drain the data into
   *
   * C++ operator precedence indicates that operator() has precedence level 2.
   * operator| has precedence 13 which means that this operator will occur first
   * before operator|.
   *
   * @param p_sink - span to load data into
   * @return drain& - self
   */
  drain& operator()(std::span<hal::byte> p_sink)
  {
    m_sink = p_sink;
    return *this;
  }

  /**
   * @brief Copy data from the input data into the sink
   *
   * @param p_input_data - input data to be drained into the sink
   * @param p_self - self
   * @return std::span<const hal::byte> - the remaining
   */
  friend std::span<const hal::byte> operator|(
    const std::span<const hal::byte>& p_input_data,
    drain& p_self)
  {
    if (p_input_data.empty()) {
      return p_input_data;
    }

    if (p_self.m_sink.empty()) {
      return p_input_data;
    }

    if (p_self.m_bytes_drained >= *p_self.m_bytes_to_drain) {
      return p_input_data;
    }

    auto min = std::min(p_input_data.size(), *p_self.m_bytes_to_drain);
    std::copy_n(p_input_data.begin(), min, p_self.m_sink.begin());

    return p_input_data.subspan(min);
  }

  work_state state()
  {
    if (m_bytes_drained == *m_bytes_to_drain) {
      return work_state::finished;
    }
    return work_state::in_progress;
  }

  void set_drain_amount_reference(const size_t& p_bytes_to_drain)
  {
    m_bytes_to_drain = &p_bytes_to_drain;
  }

private:
  std::span<hal::byte> m_sink;
  const size_t* m_bytes_to_drain;
  size_t m_bytes_drained = 0;
};