Base class for scheduling services entries. More...

#include <scheduling.h>

Collaboration diagram for HF::Core::Scheduling::Entry< _Type >:

Public Member Functions
	Entry (uint8_t _id, uint8_t _status, _Type _t, uint8_t _pid)
	Constructor. More...

bool	active (uint32_t _time) const
	Check if the current entry is runnable at _time. More...

void	step (void)
	Increment the next_run attribute.

uint16_t	size () const
	Number bytes needed to serialize the message. More...

uint16_t	pack (Common::ByteArray &array, uint16_t offset=0) const
	Write the object on to a ByteArray so it can be sent over the network. More...

uint16_t	unpack (const Common::ByteArray &array, uint16_t offset=0)
	Read a message from a ByteArray. More...

Data Fields
uint8_t	id
	Event ID. More...

bool	status
	Event Status. More...

_Type	time
	Scheduler configuration. More...

uint8_t	pid
	Program ID to be invoked. More...

uint32_t	next_run
	Next run timestamp. More...

Static Public Attributes
static constexpr uint16_t	START_ID = 0x00
	Lower bound for the entries ID. More...

static constexpr uint16_t	MAX_ID = 0xFE
	Upper bound for the entries ID. More...

static constexpr uint16_t	AVAILABLE_ID = 0xFF
	Special ID for system allocated ID. More...

static constexpr uint16_t	min_size
	Minimum pack/unpack required data size.

Detailed Description

template<typename _Type>
struct HF::Core::Scheduling::Entry< _Type >

Base class for scheduling services entries.

Template Parameters

_Type the specific data for scheduling service entry.

Definition at line 175 of file scheduling.h.

Constructor & Destructor Documentation

◆ Entry()

template<typename _Type>

HF::Core::Scheduling::Entry< _Type >::Entry	(	uint8_t	_id,
		uint8_t	_status,
		_Type	_t,
		uint8_t	_pid
	)

inline

Constructor.

Parameters

[in]	_id	the entry ID.
[in]	_status	the entry status.
[in]	_t	the specific data for the scheduling service.
[in]	_pid	the batch program ID to be run.

Definition at line 193 of file scheduling.h.

                                                                        :
                id(_id), status(_status), time(_t), pid(_pid), next_run(time.first())
             {}

Member Function Documentation

◆ active()

template<typename _Type>

bool HF::Core::Scheduling::Entry< _Type >::active ( uint32_t _time ) const

inline

Check if the current entry is runnable at _time.

Parameters

[in] _time the system time.

Return values

false	if the entry can't run.
true	if the entry can run.

Definition at line 211 of file scheduling.h.

References HF::Core::Scheduling::Entry< _Type >::next_run, HF::Core::Scheduling::Entry< _Type >::status, and HF::Core::Scheduling::Entry< _Type >::time.

             {
                return (status == 0x01 &&
                        time.active(_time) &&
                        _time >= next_run);
             }

◆ pack()

template<typename _Type>

uint16_t HF::Core::Scheduling::Entry< _Type >::pack	(	Common::ByteArray &	array,
		uint16_t	offset = `0`
	)		const

inline

Write the object on to a ByteArray so it can be sent over the network.

The buffer passed in MUST have enough size to hold the serialized object, e.g.,

Serializable obj;
ByteArray payload(obj.size());
obj.pack(payload);

Parameters

[in,out]	array	ByteArray reference to write the object to.
[in]	offset	offset to start writing to.

Returns: the number of bytes written.

Definition at line 239 of file scheduling.h.

References HF_SERIALIZABLE_CHECK, HF::Core::Scheduling::Entry< _Type >::pid, HF::Core::Scheduling::Entry< _Type >::size(), HF::Core::Scheduling::Entry< _Type >::status, HF::Core::Scheduling::Entry< _Type >::time, and HF::Common::ByteArray::write().

             {
                HF_SERIALIZABLE_CHECK(array, offset, size());
 
                uint16_t start = offset;
 
                offset += array.write(offset, id);
                offset += array.write(offset, static_cast<uint8_t>((status << 7) & 0x80));
                offset += time.pack(array, offset);
                offset += array.write(offset, pid);
 
                return (offset - start);
             }

Here is the call graph for this function:

◆ size()

template<typename _Type>

uint16_t HF::Core::Scheduling::Entry< _Type >::size ( ) const

inline

Number bytes needed to serialize the message.

Returns: number of bytes the message requires to be serialized.

Definition at line 233 of file scheduling.h.

References HF::Core::Scheduling::Entry< _Type >::min_size.

Referenced by HF::Core::Scheduling::Entry< _Type >::pack(), and HF::Core::Scheduling::Entry< _Type >::unpack().

             {
                return min_size;
             }

Here is the caller graph for this function:

◆ unpack()

template<typename _Type>

uint16_t HF::Core::Scheduling::Entry< _Type >::unpack	(	const Common::ByteArray &	array,
		uint16_t	offset = `0`
	)

inline

Read a message from a ByteArray.

Parameters

[in]	array	ByteArray reference to read the message from.
[in]	offset	offset to start reading from.

Returns: the number of bytes read.

Definition at line 254 of file scheduling.h.

References HF_ASSERT, HF_SERIALIZABLE_CHECK, HF::Core::Scheduling::Entry< _Type >::min_size, HF::Core::Scheduling::Entry< _Type >::pid, HF::Common::ByteArray::read(), HF::Core::Scheduling::Entry< _Type >::size(), HF::Core::Scheduling::Entry< _Type >::status, and HF::Core::Scheduling::Entry< _Type >::time.

             {
                HF_SERIALIZABLE_CHECK(array, offset, min_size);
 
                uint16_t start = offset;
 
                offset += array.read(offset, id);
 
                uint8_t flags = 0;
                offset += array.read(offset, flags);
                status  = (flags >> 7) & 0x01;
 
                uint16_t size = time.unpack(array, offset);
                HF_ASSERT(size != 0, {return 0;});
                offset += size;
 
                offset += array.read(offset, pid);
 
                return (offset - start);
             }