atomic_var.hpp

Go to the documentation of this file.

//
// Copyright (c) 2019 Erwin Rol <erwin@erwinrol.com>
//
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef ZPP_INCLUDE_ZPP_ATOMIC_VAR_HPP
#define ZPP_INCLUDE_ZPP_ATOMIC_VAR_HPP
 
#include <zephyr/sys/atomic.h>
#include <zephyr/sys/__assert.h>
 
#include <cstddef>
 
namespace zpp {
 
class atomic_var {
public:
  using value_type = atomic_val_t;
public:
  constexpr atomic_var() noexcept = default;
 
  explicit atomic_var(value_type v) noexcept
  {
    store(v);
  }
 
  atomic_var(const atomic_var& rhs) noexcept
  {
    store(rhs.load());
  }
 
  atomic_var& operator=(const atomic_var& rhs) noexcept
  {
    store(rhs.load());
    return *this;
  }
 
  constexpr size_t bit_count() const noexcept
  {
    return sizeof(value_type) * 8;
  }
 
  [[nodiscard]] bool cas(value_type old_val, value_type new_val) noexcept
  {
    return atomic_cas(&m_var, old_val, new_val);
  }
 
  value_type fetch_add(value_type val) noexcept
  {
    return atomic_add(&m_var, val);
  }
 
  value_type fetch_sub(value_type val) noexcept
  {
    return atomic_sub(&m_var, val);
  }
 
  value_type fetch_or(value_type val) noexcept
  {
    return atomic_or(&m_var, val);
  }
 
  value_type fetch_xor(value_type val) noexcept
  {
    return atomic_xor(&m_var, val);
  }
 
  value_type fetch_and(value_type val) noexcept
  {
    return atomic_and(&m_var, val);
  }
 
  value_type fetch_nand(value_type val) noexcept
  {
    return atomic_nand(&m_var, val);
  }
 
  value_type fetch_inc() noexcept
  {
    return atomic_inc(&m_var);
  }
 
  value_type fetch_dec() noexcept
  {
    return atomic_dec(&m_var);
  }
 
  [[nodiscard]] value_type load() const noexcept
  {
    return atomic_get(&m_var);
  }
 
  value_type store(value_type val) noexcept
  {
    return atomic_set(&m_var, val);
  }
 
  value_type clear() noexcept
  {
    return atomic_clear(&m_var);
  }
 
  [[nodiscard]] bool load(size_t bit) const noexcept
  {
    __ASSERT_NO_MSG(bit < (sizeof(value_type) * 8));
    return atomic_test_bit(&m_var, bit);
  }
 
  void store(size_t bit, bool val) noexcept
  {
    __ASSERT_NO_MSG(bit < (sizeof(value_type) * 8));
    atomic_set_bit_to(&m_var, bit, val);
  }
 
  void set(size_t bit) noexcept
  {
    __ASSERT_NO_MSG(bit < (sizeof(value_type) * 8));
    atomic_set_bit(&m_var, bit);
  }
 
  void clear(size_t bit) noexcept
  {
    __ASSERT_NO_MSG(bit < (sizeof(value_type) * 8));
    atomic_clear_bit(&m_var, bit);
  }
 
  [[nodiscard]] bool fetch_and_clear(size_t bit) noexcept
  {
    __ASSERT_NO_MSG(bit < (sizeof(value_type) * 8));
    return atomic_test_and_clear_bit(&m_var, bit);
  }
 
  [[nodiscard]] bool fetch_and_set(size_t bit) noexcept
  {
    __ASSERT_NO_MSG(bit < (sizeof(value_type) * 8));
    return atomic_test_and_set_bit(&m_var, bit);
  }
 
  operator value_type () const noexcept
  {
    return load();
  }
 
  value_type operator=(value_type val) noexcept
  {
    return store(val);
  }
 
  value_type operator++() noexcept
  {
    return fetch_add(1) + 1;
  }
 
  value_type operator++(int) noexcept
  {
    return fetch_add(1);
  }
 
  value_type operator--() noexcept
  {
    return fetch_sub(1) - 1;
  }
 
  value_type operator--(int) noexcept
  {
    return fetch_sub(1);
  }
 
  value_type operator+=(value_type val) noexcept
  {
    return fetch_add(val) + val;
  }
 
  value_type operator-=(value_type val) noexcept
  {
    return fetch_sub(val) - val;
  }
 
  value_type operator&=(value_type val) noexcept
  {
    return fetch_and(val) & val;
  }
 
  value_type operator|=(value_type val) noexcept
  {
    return fetch_or(val) | val;
  }
 
  value_type operator^=(value_type val) noexcept
  {
    return fetch_xor(val) ^ val;
  }
private:
  atomic_t m_var{};
};
 
} // namespace zpp
 
#endif // ZPP_INCLUDE_ZPP_ATOMIC_VAR_HPP