os::rtos::internal::event_flags Class Reference

Internal event flags implementation. More...

#include <os-flags.h>

Public Member Functions
Constructors & Destructor
	event_flags ()=default
	Construct an internal event flags object instance.
	~event_flags ()=default
	Destruct the internal event flags object instance.
Public Member Functions
result_t	raise (flags::mask_t mask, flags::mask_t *oflags)
	Raise event flags.
bool	check_raised (flags::mask_t mask, flags::mask_t *oflags, flags::mode_t mode)
	Check if expected flags are raised.
flags::mask_t	get (flags::mask_t mask, flags::mode_t mode)
	Get (and possibly clear) event flags.
result_t	clear (flags::mask_t mask, flags::mask_t *oflags)
	Clear event flags.
flags::mask_t	mask (void)
	Get the flags mask.

Detailed Description

Definition at line 46 of file os-flags.h.

Constructor & Destructor Documentation

event_flags()

os::rtos::internal::event_flags::event_flags ( )

default

~event_flags()

os::rtos::internal::event_flags::~event_flags ( )

default

Member Function Documentation

check_raised()

bool os::rtos::internal::event_flags::check_raised	(	flags::mask_t	mask,
		flags::mask_t *	oflags,
		flags::mode_t	mode
	)

Parameters

[in]	mask	The expected flags (OR-ed bit-mask); if flags::any, any flag raised will do it.
[out]	oflags	Pointer where to store the current flags; may be nullptr.
[in]	mode	Mode bits to select if either all or any flags in the mask are expected, and if the flags should be cleared.

Return values

true	The expected flags are raised.
false	The expected flags are not raised.

Definition at line 63 of file os-flags.cpp.

      {
        if (mask == flags::any)
          {
            // Any flag will do it.
            if (flags_mask_ != 0)
              {
                if (oflags != nullptr)
                  {
                    *oflags = flags_mask_;
                  }
 
                if (mode & flags::mode::clear)
                  {
                    // Clear them all.
                    flags_mask_ = 0;
                  }
                return true;
              }
          }
        else if (((((mode & flags::mode::all) != 0))
                  && ((flags_mask_ & mask) == mask))
                 || (((mode & flags::mode::any) != 0)
                     && ((flags_mask_ & mask) != 0)))
          {
            if (oflags != nullptr)
              {
                *oflags = (flags_mask_ & mask);
              }
 
            if (mode & flags::mode::clear)
              {
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
                // Clear desired flags.
                flags_mask_ &= ~mask;
#pragma GCC diagnostic pop
              }
            return true;
          }
 
        return false;
      }

References os::rtos::flags::mode::all, os::rtos::flags::mode::any, os::rtos::flags::any, os::rtos::flags::mode::clear, and mask().

clear()

result_t os::rtos::internal::event_flags::clear	(	flags::mask_t	mask,
		flags::mask_t *	oflags
	)

Parameters

[in]	mask	The OR-ed flags to clear.
[out]	oflags	Optional pointer where to store the previous value of the flags; may be nullptr.

Return values

result::ok	The flags were cleared.
EINVAL	The mask is zero.

Definition at line 149 of file os-flags.cpp.

      {
        os_assert_err (mask != 0, EINVAL);
 
        {
          // ----- Enter critical section -------------------------------------
          interrupts::critical_section ics;
 
          if (oflags != nullptr)
            {
              *oflags = flags_mask_;
            }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
          // Clear the selected bits; leave the rest untouched.
          flags_mask_ &= ~mask;
#pragma GCC diagnostic pop
 
          // ----- Exit critical section --------------------------------------
        }
 
        return result::ok;
      }

References mask(), os::rtos::result::ok, and os_assert_err.

get()

flags::mask_t os::rtos::internal::event_flags::get	(	flags::mask_t	mask,
		flags::mode_t	mode
	)

Parameters

[in]	mask	The OR-ed flags to get/clear; can be flags::any.
[in]	mode	Mode bits to select if the flags should be cleared (the other bits are ignored).

Returns

The selected bits from the flags mask.

Definition at line 113 of file os-flags.cpp.

      {
        flags::mask_t ret;
        {
          // ----- Enter critical section -------------------------------------
          interrupts::critical_section ics;
 
          if (mask == 0)
            {
              // Return the entire mask.
              ret = flags_mask_;
            }
          else
            {
              ret = flags_mask_ & mask;
              if ((mode & flags::mode::clear) != 0)
                {
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
                  // Clear the selected bits; leave the rest untouched.
                  flags_mask_ &= ~mask;
#pragma GCC diagnostic pop
                }
            }
          // ----- Exit critical section --------------------------------------
        }
 
        // Return the selected bits.
        return ret;
      }

References os::rtos::flags::mode::clear, and mask().

mask()

flags::mask_t os::rtos::internal::event_flags::mask ( void  )

inline

Returns

The internal bit-mask.

Definition at line 189 of file os-flags.h.

      {
        return flags_mask_;
      }

Referenced by check_raised(), clear(), get(), and raise().

raise()

result_t os::rtos::internal::event_flags::raise	(	flags::mask_t	mask,
		flags::mask_t *	oflags
	)

Parameters

[in]	mask	The OR-ed flags to raise.
[out]	oflags	Optional pointer where to store the new value of the flags; may be nullptr.

Return values

result::ok	The flags were raised.
EINVAL	The mask is zero.
ENOTRECOVERABLE	Raise failed.

Definition at line 33 of file os-flags.cpp.

      {
        os_assert_err (mask != 0, EINVAL);
 
        assert (port::interrupts::is_priority_valid ());
 
        {
          // ----- Enter critical section -------------------------------------
          interrupts::critical_section ics;
 
          if (oflags != nullptr)
            {
              *oflags = flags_mask_;
            }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
          flags_mask_ |= mask;
#pragma GCC diagnostic pop
 
          // ----- Exit critical section --------------------------------------
        }
        return result::ok;
      }

References mask(), os::rtos::result::ok, and os_assert_err.

---

The documentation for this class was generated from the following files:

• os-flags.h
• os-flags.cpp