EEPROM.hh

Go to the documentation of this file.

#ifndef COSA_EEPROM_HH
#define COSA_EEPROM_HH

#include "Cosa/Types.h"
#include "Cosa/Power.hh"

class EEPROM {
public:
  class Device {
  public:
    virtual bool is_ready();

    virtual int read(void* dest, const void* src, size_t size);

    virtual int write(void* dest, const void* src, size_t size);

    static Device eeprom;
  };

public:
  EEPROM(Device* dev = &Device::eeprom) : m_dev(dev) {}

  bool is_ready()
    __attribute__((always_inline))
  {
    return (m_dev->is_ready());
  }

  void write_await()
    __attribute__((always_inline))
  {
    while (!is_ready()) yield();
  }

  int read(void* dest, const void* src, size_t size)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, size));
  }

  template<class T> int read(T* dest, const T* src)
  {
    return (m_dev->read(dest, src, sizeof(T)));
  }

  int read(unsigned char* dest, const unsigned char* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(unsigned char)));
  }

  int read(unsigned short* dest, const unsigned short* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(unsigned short)));
  }

  int read(unsigned int* dest, const unsigned int* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(unsigned int)));
  }

  int read(unsigned long* dest, const unsigned long* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(unsigned long)));
  }

  int read(char* dest, const char* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(char)));
  }

  int read(short* dest, const short* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(short)));
  }

  int read(int* dest, const int* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(int)));
  }

  int read(long* dest, const long* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(long)));
  }

  int read(float* dest, const float* src)
    __attribute__((always_inline))
  {
    return (m_dev->read(dest, src, sizeof(float)));
  }

  int write(void* dest, const void* src, size_t size)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, src, size));
  }

  template<class T> int write(T* dest, const T* src)
  {
    return (m_dev->write(dest, src, sizeof(T)));
  }

  int write(unsigned char* dest, unsigned char src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(unsigned char)));
  }

  int write(unsigned short* dest, unsigned short src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(unsigned short)));
  }

  int write(unsigned int* dest, unsigned int src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(unsigned int)));
  }

  int write(unsigned long* dest, unsigned long src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(unsigned long)));
  }

  int write(char* dest, char src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(char)));
  }

  int write(short* dest, short src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(short)));
  }

  int write(int* dest, int src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(int)));
  }

  int write(long* dest, long src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(long)));
  }

  int write(float* dest, float src)
    __attribute__((always_inline))
  {
    return (m_dev->write(dest, &src, sizeof(float)));
  }

private:
  Device* m_dev;                
};

#endif