attrs.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 <cstddef>
#include <type_traits>
 
#include "pw_span/span.h"
#include "pw_thread/priority.h"
#include "pw_thread/stack.h"
 
namespace pw {
 
class ThreadAttrs {
 public:
  constexpr ThreadAttrs()
      : name_(""),
        priority_(),
        stack_(nullptr),
        stack_size_(thread::backend::kDefaultStackSizeBytes) {}
 
  constexpr ThreadAttrs(const ThreadAttrs&) = default;
  constexpr ThreadAttrs& operator=(const ThreadAttrs&) = default;
 
  constexpr const char* name() const { return name_; }
 
  constexpr ThreadAttrs& set_name(const char* name) {
    PW_DASSERT(name != nullptr);
    name_ = name;
    return *this;
  }
 
  constexpr ThreadAttrs& set_name(std::nullptr_t) = delete;
 
  constexpr ThreadPriority priority() const { return priority_; }
 
  constexpr ThreadAttrs& set_priority(ThreadPriority priority) {
    priority_ = priority;
    return *this;
  }
 
  constexpr auto native_stack() const {
    PW_ASSERT(has_external_stack());
    return internal::ThreadStackSpan(stack_, stack_size_);
  }
 
  constexpr auto native_stack_pointer() const { return stack_; }
 
  constexpr auto native_stack_size() const {
    PW_ASSERT(has_external_stack());
    return stack_size_;
  }
 
  constexpr size_t stack_size_bytes() const {
    if (has_external_stack()) {
      return internal::NativeStackSizeBytes(stack_size_);
    }
    return stack_size_;
  }
 
  constexpr ThreadAttrs& set_stack_size_bytes(size_t stack_size_bytes) {
    PW_ASSERT(!has_external_stack());
    stack_size_ = stack_size_bytes;
    return *this;
  }
 
  template <size_t kStackSizeBytes>
  constexpr ThreadAttrs& set_stack(ThreadStack<kStackSizeBytes>& stack) {
    stack_ = stack.native_pointer();
    stack_size_ = stack.native_size();
    return *this;
  }
 
  constexpr ThreadAttrs& clear_stack() {
    stack_ = nullptr;
    stack_size_ = thread::backend::kDefaultStackSizeBytes;
    return *this;
  }
 
  [[nodiscard]] constexpr bool has_external_stack() const {
    return stack_ != nullptr;
  }
 
 private:
  const char* name_;
  ThreadPriority priority_;
 
  internal::ThreadStackPointer stack_;
  size_t stack_size_;
};
 
}  // namespace pw