trace_buffer.h

// Copyright 2020 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 "pw_bytes/span.h"
#include "pw_containers/algorithm.h"
#include "pw_containers/inline_var_len_entry_queue.h"
#include "pw_status/status.h"
#include "pw_trace_tokenized/config.h"
 
namespace pw {
 
 
namespace trace {
namespace internal {
 
// Forward declaration.
class TraceBufferImpl;
 
}  // namespace internal
 
class TraceBuffer {
 public:
  InlineVarLenEntryQueue<>& queue() { return queue_; }
 
  constexpr Status PeekFront(ByteSpan data, size_t* bytes_read_out) const;
 
  constexpr Status PopFront();
 
  constexpr size_t EntryCount() const { return queue_.size(); }
 
  constexpr Status CheckForCorruption() { return OkStatus(); }
 
  constexpr void Clear() { queue_.clear(); }
 
  constexpr size_t TotalUsedBytes() const {
    return queue_.encoded_size_bytes();
  }
 
 private:
  friend class ::pw::trace::internal::TraceBufferImpl;
 
  constexpr explicit TraceBuffer(InlineVarLenEntryQueue<>& queue)
      : queue_(queue) {}
 
  InlineVarLenEntryQueue<>& queue_;
};
 
void ClearBuffer();
 
TraceBuffer* GetBuffer();
 
ConstByteSpan DeringAndViewRawBuffer();
 
// Constexpr method implementations
 
constexpr Status TraceBuffer::PeekFront(ByteSpan data,
                                        size_t* bytes_read_out) const {
  if (queue_.empty()) {
    return Status::OutOfRange();
  }
  auto entry = queue_.front();
  size_t len = std::min(data.size(), entry.size());
  pw::copy(
      entry.begin(),
      entry.begin() +
          static_cast<
              InlineVarLenEntryQueue<>::value_type::iterator::difference_type>(
              len),
      data.begin());
  *bytes_read_out = len;
  return data.size() < entry.size() ? Status::ResourceExhausted() : OkStatus();
}
 
constexpr Status TraceBuffer::PopFront() {
  if (queue_.empty()) {
    return Status::OutOfRange();
  }
  queue_.pop();
  return OkStatus();
}
 
}  // namespace trace
 
 
}  // namespace pw