Ciao.hh

Go to the documentation of this file.

#ifndef COSA_CIAO_HH
#define COSA_CIAO_HH

#include "Cosa/IOStream.hh"

class Ciao {
public:
  enum {
    MASK_ATTR = 0x0f,
    COUNT0_ATTR = 0x00,
    COUNT4_MASK = 0x07,
    COUNT8_ATTR = 0x08,
    COUNT16_ATTR = 0x09,
    END_SEQUENCE_ATTR = 0x0f
  } __attribute__((packed));

  enum {
    MASK_TYPE = 0xf0,
    UINT8_TYPE = 0x00,
    UINT16_TYPE = 0x10,
    UINT32_TYPE = 0x20,
    UINT64_TYPE = 0x30,
    USER8_DESC_START = 0x40,
    USER8_DESC_END = USER8_DESC_START | END_SEQUENCE_ATTR,
    USER16_DESC_START = 0x50,
    USER16_DESC_END = USER16_DESC_START | END_SEQUENCE_ATTR,
    USER8_TYPE = 0x60,
    USER16_TYPE = 0x70,
    INT8_TYPE = 0x80,
    INT16_TYPE = 0x90,
    INT32_TYPE = 0xa0,
    INT64_TYPE = 0xb0,
    FLOAT16_TYPE = 0xc0,
    FLOAT32_TYPE = 0xd0,
    FLOAT64_TYPE = 0xe0,
    FLOAT80_TYPE = 0xf0
  } __attribute__((packed));

  class Descriptor {
  public:
    enum {
      HEADER_ID = 0x00,        
      COSA_FAI_ID = 0x10,      
      USER_ID = 0x0100         
    };
    struct member_t {
      uint8_t type;
      uint16_t count;
      const char* name;
      const struct user_t* desc;
    };
    struct user_t {
      uint16_t id;
      const char* name;
      const member_t* member;
      uint8_t count;
    };
    static const user_t header_t PROGMEM;
  };

  struct header_t {
    char* magic;
    uint8_t major;
    uint8_t minor;
    uint8_t endian;
  };
  enum {
    LITTLE_ENDIAN = 0,
    BIG_ENDIAN = 1
  } __attribute__((packed));

public:
  Ciao(IOStream::Device* dev = NULL) : m_dev(dev) {}

  void set(IOStream::Device* dev)
    __attribute__((always_inline))
  {
    if (dev == NULL) return;
    m_dev = dev;
  }

  void begin();

  void write(char* s);

  void write(str_P s);

  void write(uint8_t value);

  void write(uint8_t* buf, uint16_t count);

  void write(uint16_t value);

  void write(uint16_t* buf, uint16_t count);

  void write(uint32_t value);

  void write(uint32_t* buf, uint16_t count);

  void write(uint64_t value);

  void write(uint64_t* buf, uint16_t count);

  void write(int8_t value);

  void write(int8_t* buf, uint16_t count);

  void write(int16_t value);

  void write(int16_t* buf, uint16_t count);

  void write(int32_t value);

  void write(int32_t* buf, uint16_t count);

  void write(int64_t value);

  void write(int64_t* buf, uint16_t count);

  void write(float value);

  void write(float* buf, uint16_t count);

  void write(const Descriptor::user_t* desc);

  void write(const Descriptor::user_t* desc, void* buf, uint16_t count);

protected:
  void write(uint8_t type, uint16_t count);

  IOStream::Device* m_dev;
};

#endif