Storage.h

Go to the documentation of this file.

#ifndef STORAGE_H
#define STORAGE_H

class Storage {
public:
  const uint32_t SIZE;

  Storage(uint32_t size) : SIZE(size), m_addr(0) {}

  uint32_t room()
  {
    return (SIZE - m_addr);
  }

  uint32_t alloc(size_t count)
  {
    if (count > room()) return (UINT32_MAX);
    uint32_t res = m_addr;
    m_addr += count;
    return (res);
  }

  void free(uint32_t addr)
  {
    if (addr < m_addr) m_addr = addr;
  }

  virtual int read(void* dest, uint32_t src, size_t count) = 0;

  virtual int write(uint32_t dest, const void* src, size_t count) = 0;

  class Block {
  public:
    Block(Storage &mem, uint32_t size) :
      SIZE(size),
      m_mem(mem),
      m_addr(m_mem.alloc(size))
    {
    }

    ~Block()
    {
      m_mem.free(m_addr);
    }

    uint32_t addr()
    {
      return (m_addr);
    }

    int read(void* buf, uint32_t offset, size_t size)
    {
      if (offset + size <= SIZE)
        return (m_mem.read(buf, m_addr + offset, size));
      return (-1);
    }

    int write(uint32_t offset, const void* buf, size_t size)
    {
      if (offset + size <= SIZE)
        return (m_mem.write(m_addr + offset, buf, size));
      return (-1);
    }

    const uint32_t SIZE;

  protected:
    Storage& m_mem;

    const uint32_t m_addr;
  };

  class Cache : public Block {
  public:
    Cache(Storage &mem, void* buf, size_t size, size_t nmemb = 1) :
      Block(mem, size * nmemb),
      MSIZE(size),
      NMEMB(nmemb),
      m_buf(buf)
    {
    }

    uint32_t addr(size_t ix = 0)
    {
      if (ix == 0)
        return (m_addr);
      if (ix < NMEMB)
        return (m_addr + (ix * MSIZE));
      return (UINT32_MAX);
    }

    int read(size_t ix = 0)
    {
      if (ix == 0)
        return (m_mem.read(m_buf, m_addr, MSIZE));
      if (ix < NMEMB)
        return (m_mem.read(m_buf, m_addr + (ix * MSIZE), MSIZE));
      return (-1);
    }

    int write(size_t ix = 0)
    {
      if (ix == 0)
        return (m_mem.write(m_addr, m_buf, MSIZE));
      if (ix < NMEMB)
        return (m_mem.write(m_addr + (ix * MSIZE), m_buf, MSIZE));
      return (-1);
    }

    const size_t MSIZE;

    const size_t NMEMB;

  protected:
    void* m_buf;
  };

  class Stream : public ::Stream {
  public:
    Stream(Storage &mem, size_t size) :
      SIZE(size),
      m_mem(mem),
      m_addr(m_mem.alloc(size)),
      m_put(0),
      m_get(0),
      m_count(0)
    {
    }

    uint32_t addr()
    {
      return (m_addr);
    }

    virtual size_t write(uint8_t byte)
    {
      if (m_count == SIZE) return (0);
      m_mem.write(m_addr + m_put, &byte, sizeof(byte));
      m_count += 1;
      m_put += 1;
      if (m_put == SIZE) m_put = 0;
      return (sizeof(byte));
    }

    virtual size_t write(const uint8_t *buffer, size_t size)
    {
      uint16_t room = SIZE - m_count;
      if (room == 0) return (0);
      if (size > room) size = room;
      size_t res = size;
      room = SIZE - m_put;
      if (size > room) {
        m_mem.write(m_addr + m_put, buffer, room);
        buffer += room;
        size -= room;
        m_count += room;
        m_put = 0;
      }
      m_mem.write(m_addr + m_put, buffer, size);
      m_count += size;
      m_put += size;
      return (res);
    }

    virtual int available()
    {
      return (m_count);
    }

    virtual int peek()
    {
      if (m_count == 0) return (-1);
      uint8_t res = 0;
      m_mem.read(&res, m_addr + m_get, sizeof(res));
      return (res);
    }

    virtual int read()
    {
      if (m_count == 0) return (-1);
      uint8_t res = 0;
      m_mem.read(&res, m_addr + m_get, sizeof(res));
      m_count -= 1;
      m_get += 1;
      if (m_get == SIZE) m_get = 0;
      return (res);
    }

    virtual void flush()
    {
      m_put = 0;
      m_get = 0;
      m_count = 0;
    }

    size_t SIZE;

  protected:
    Storage& m_mem;

    const uint32_t m_addr;

    uint16_t m_put;

    uint16_t m_get;

    uint16_t m_count;
  };

protected:
  uint32_t m_addr;
};
#endif