Registry.hh

Go to the documentation of this file.

#ifndef COSA_REGISTRY_HH
#define COSA_REGISTRY_HH

#include "Cosa/Types.h"
#include "Cosa/EEPROM.hh"
#include "Cosa/IOStream.hh"

class Registry {
public:
  enum type_t {
    ITEM = 0,                   
    ITEM_LIST = 1,              
    ACTION = 2,                 
    BLOB = 3,                   
    APPL = 4                    
  } __attribute__((packed));

  enum storage_t {
    IN_PROGMEM = 0,             
    IN_SRAM = 1,                
    IN_EEMEM = 2,               
  } __attribute__((packed));

  static const uint8_t STORAGE_MASK = 0x7f;

  static const uint8_t READONLY = 0x80;

  struct item_t {
    type_t type;                
    str_P name;                 
    uint8_t attr;               
  };

  typedef const PROGMEM item_t* item_P;

  typedef const PROGMEM item_P* item_vec_P;

  static type_t get_type(item_P item)
  {
    return ((type_t) pgm_read_byte(&item->type));
  }

  static str_P get_name(item_P item)
    __attribute__((always_inline))
  {
    return ((str_P) pgm_read_word(&item->name));
  }

  static storage_t get_storage(item_P item)
    __attribute__((always_inline))
  {
    return ((storage_t) (pgm_read_byte(&item->attr) & STORAGE_MASK));
  }

  static bool is_readonly(item_P item)
    __attribute__((always_inline))
  {
    return ((pgm_read_byte(&item->attr) & READONLY) != 0);
  }

  struct item_list_t {
    item_t item;                
    uint8_t length;             
    item_vec_P list;            
  };

  typedef const PROGMEM item_list_t* item_list_P;

  static item_list_P to_list(item_P item)
    __attribute__((always_inline))
  {
    return (get_type(item) == ITEM_LIST ? (item_list_P) item : NULL);
  }

  static int get_length(item_list_P list)
    __attribute__((always_inline))
  {
    if (UNLIKELY(get_type(&list->item) != ITEM_LIST)) return (EINVAL);
    return ((int) pgm_read_byte(&list->length));
  }

  class Iterator {
  private:
    item_vec_P m_vec;           
    uint8_t m_length;           
    uint8_t m_next;             
  public:
    Iterator(item_list_P list) :
      m_vec((item_vec_P) pgm_read_word(&list->list)),
      m_length((uint8_t) pgm_read_byte(&list->length)),
      m_next(0)
    {}

    item_P next()
      __attribute__((always_inline))
    {
      if (UNLIKELY(m_next == m_length)) return (NULL);
      return ((item_P) pgm_read_word(&m_vec[m_next++]));
    }

    void reset()
      __attribute__((always_inline))
    {
      m_next = 0;
    }
  };

  class Action {
  public:
    virtual int run(void* buf, size_t size) = 0;
  };

  struct action_t {
    item_t item;                
    Action* obj;                
  };

  typedef const PROGMEM action_t* action_P;

  static action_P to_action(item_P item)
    __attribute__((always_inline))
  {
    return (get_type(item) == ACTION ? (action_P) item : NULL);
  }

  static int run(action_P action, void* buf, size_t size);

  struct blob_t {
    item_t item;                
    void* value;                
    size_t size;                
  };

  typedef const PROGMEM blob_t* blob_P;

  static blob_P to_blob(item_P item)
  {
    return (get_type(item) >= BLOB ? (blob_P) item : NULL);
  }

  int get_value(blob_P blob, void* buf, size_t len);

  template<class T> bool get_value(blob_P blob, T* value)
  {
    return (get_value(blob, value, sizeof(T)) == sizeof(T));
  }

  int set_value(blob_P blob, const void* buf, size_t len);

  template<class T> bool set_value(blob_P blob, const T* value)
  {
    return (set_value(blob, value, sizeof(T)) == sizeof(T));
  }

  static const size_t PATH_MAX = 8;

  Registry(item_list_P root, EEPROM::Device* eeprom = NULL) :
    m_root(root),
    m_eeprom(eeprom == NULL ? &EEPROM::Device::eeprom : eeprom)
  {}

  item_P lookup(const uint8_t* path = NULL, size_t count = 0);

  void print(IOStream& outs, const uint8_t* path, size_t count);

  int apply(const uint8_t* path, size_t count, void* buf, size_t len)
  {
    return (run(to_action(lookup(path, count)), buf, len));
  }

private:
  item_list_P m_root;

  EEPROM::Device* m_eeprom;
};

IOStream& operator<<(IOStream& outs, Registry::item_P item);

IOStream& operator<<(IOStream& outs, Registry::item_list_P list);

#define REGISTRY_BEGIN(var,name)                        \
  const char var ## _name[] __PROGMEM = name;           \
  const Registry::item_P var ## _list[] __PROGMEM = {

#define REGISTRY_LIST_ITEM(var) &var.item,
#define REGISTRY_BLOB_ITEM(var) &var ## _blob.item,
#define REGISTRY_ACTION_ITEM(var) &var ## _action.item,

#define REGISTRY_END(var)                               \
  };                                                    \
  const Registry::item_list_t var __PROGMEM = {         \
    {                                                   \
      Registry::ITEM_LIST,                              \
      (str_P) var ## _name,                             \
      Registry::IN_PROGMEM | Registry::READONLY         \
    },                                                  \
    membersof(var ## _list),                            \
    var ## _list                                        \
  };

#define REGISTRY_ACTION(var,name)                       \
  const char var ## _name[] __PROGMEM = name;           \
  const Registry::action_t var ## _action __PROGMEM = { \
    {                                                   \
      Registry::ACTION,                                 \
      (str_P) var ## _name,                             \
      Registry::IN_SRAM | Registry::READONLY            \
    },                                                  \
    &var                                                \
  };

#define REGISTRY_BLOB(var,name,mem,readonly)            \
  const char var ## _blob_name[] __PROGMEM = name;      \
  const Registry::blob_t var ## _blob __PROGMEM = {     \
    {                                                   \
      Registry::BLOB,                                   \
      (str_P) var ## _blob_name,                        \
      Registry::IN_ ## mem | (readonly << 7)            \
    },                                                  \
    (void*) &var,                                       \
    sizeof(var)                                         \
  };

#define REGISTRY_BLOB_VAR(type,var,name,value,readonly) \
  static type var = value;                              \
  REGISTRY_BLOB(var,name,SRAM,readonly)

#define REGISTRY_BLOB_STRUCT(type,var,name,readonly)    \
  static type var;                                      \
  REGISTRY_BLOB(var,name,SRAM,readonly)

#define REGISTRY_BLOB_PSTR(var,name,value)              \
  static const char var[] __PROGMEM = value;            \
  REGISTRY_BLOB(var,name,PROGMEM,true)

#endif