ManagedTaskMap.h

Go to the documentation of this file.

 
#ifndef INCLUDE_MANAGEDTASKMAP_H_
#define INCLUDE_MANAGEDTASKMAP_H_
 
 
#include "services/AManagedTask.h"
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define MTM_NULL_KEY    (0U)  
#define MTME_IS_EMPTY(p_element)  (((p_element)->value.p_mtask_obj == NULL) && ((p_element)->key == MTM_NULL_KEY))
 
 
typedef struct _MTMapValue
{
  AManagedTask *p_mtask_obj;
 
  void *p_static_param;
} MTMapValue_t;
 
typedef struct _MTMapElement
{
  uint32_t key;
 
  MTMapValue_t value;
 
} MTMapElement_t;
 
typedef struct _MTMap
{
  MTMapElement_t *p_elements;
 
  uint16_t size;
 
  uint16_t element_count;
} MTMap_t;
 
static inline
sys_error_code_t MTMap_Init(MTMap_t *_this, MTMapElement_t *p_elements, uint16_t size)
{
  assert_param(_this != NULL);
  assert_param(p_elements != NULL);
  uint32_t i = 0U;
 
  _this->p_elements = p_elements;
  _this->size = size;
  _this->element_count = 0;
 
  /* initialize all elements to NULL */
  for(i = 0; i < size; i++)
  {
    p_elements[i].key = MTM_NULL_KEY;
    p_elements[i].value.p_mtask_obj = NULL;
    p_elements[i].value.p_static_param = NULL;
  }
 
  return SYS_NO_ERROR_CODE;
}
 
static inline
MTMapValue_t *MTMap_FindByKey(MTMap_t *_this, uint32_t key)
{
  assert_param(_this != NULL);
  uint32_t i = 0U;
 
  while(_this->p_elements[i].key != key)
  {
    i++;
    if(i >= _this->size)
    {
      return NULL;
    }
  }
  return &_this->p_elements[i].value;
}
 
static inline
MTMapElement_t *MTMap_AddElement(MTMap_t *_this, uint32_t key, AManagedTask *p_instance)
{
  assert_param(_this != NULL);
  uint32_t i = 0U;
  MTMapElement_t *p_free_element = NULL;
 
  while((_this->p_elements[i].key != key) && (i < _this->size))
  {
    if ((p_free_element == NULL) && MTME_IS_EMPTY(&_this->p_elements[i]))
    {
      /* we found a free element in the map.*/
      p_free_element = &_this->p_elements[i];
    }
 
    i++;
  }
 
  if (i < _this->size)
  {
    /* the key is already present in the map*/
    if (_this->p_elements[i].value.p_mtask_obj == p_instance)
    {
      /* the element is present in the map, so we return it.*/
      p_free_element = &_this->p_elements[i];
    }
    else
    {
      /* the key is already present in the map, but it is mapped to a different IDriver instance, so we cannot add the new element.*/
      p_free_element = NULL;
    }
  }
  else
  {
    /* the key is not present in the map, so we try to add the new element*/
    if (p_free_element != NULL)
    {
      /* add the new element in the free position*/
      p_free_element->key = key;
      p_free_element->value.p_mtask_obj = p_instance;
      _this->element_count++;
    }
  }
 
  return p_free_element;
}
 
static inline
bool MTMap_RemoveElement(MTMap_t *_this, uint32_t key)
{
  assert_param(_this != NULL);
  uint32_t i = 0U;
  bool res = true;
 
  while(res && (_this->p_elements[i].key != key))
  {
    if(++i >= _this->size)
    {
      res = false;
    }
  }
 
  if (res)
  {
    _this->p_elements[i].key = MTM_NULL_KEY;
    _this->p_elements[i].value.p_mtask_obj = NULL;
    _this->p_elements[i].value.p_static_param = NULL;
    _this->element_count--;
  }
 
  return res;
}
 
static inline
bool MTMap_IsInitialized(MTMap_t *_this)
{
  assert_param(_this != NULL);
 
  return _this->size != 0;
}
 
static inline
bool MTMap_GetElementCount(const MTMap_t * const _this)
{
  assert_param(_this != NULL);
 
  return _this->element_count;
}
 
 
/* MTMapValue public API */
/*******************************/
 
static inline
void MTMapValue_SetStaticParam(MTMapValue_t *_this, void *p_static_param)
{
  assert_param(_this != NULL);
 
  _this->p_static_param = p_static_param;
}
 
static inline
void* MTMapValue_GetStaticParam(const MTMapValue_t * const _this)
{
  assert_param(_this != NULL);
 
  return _this->p_static_param;
}
 
 
/* Utility functions */
/*********************/
 
static inline
uint32_t MTMap_GetKeyForGPIO(GPIO_TypeDef *p_port, uint32_t pin)
{
  uint32_t port = (uint32_t)p_port;
  uint32_t position = 0U;
  uint32_t key = MTM_NULL_KEY;
 
  /*find the pin position*/
  uint32_t iocurrent = 0U;
  while ((iocurrent == 0U) && (position < 16))
  {
    iocurrent = (pin) & (1UL << position++);
  }
 
  if (iocurrent != 0)
  {
    key = port + position;
  }
 
  return key;
}
 
#ifdef __cplusplus
}
#endif
 
#endif /* INCLUDE_MANAGEDTASKMAP_H_ */