codeplug.hh

#ifndef CODEPLUG_HH
#define CODEPLUG_HH
 
#include <QObject>
#include <QHash>
#include "dfufile.hh"
 
//#include "userdatabase.hh"
//#include "config.hh"
 
class Config;
class ConfigItem;
 
 
class Codeplug: public DFUFile
{
  Q_OBJECT
 
public:
  class Flags {
  public:
    bool updateCodePlug;
    bool autoEnableGPS;
    bool autoEnableRoaming;
 
    Flags();
  };
 
  class Element
  {
  protected:
    struct Offset {
      struct BitOffset {
        const unsigned int byte;
        const unsigned int bit;
      };
    };
 
  public:
    struct Limit {
      template <class T> struct Range {
        const T min;
        const T max;
        inline T limit(const T &value) const {
          return std::min(max, std::max(min, value));
        }
        inline bool in(const T &value) const {
          return (value <= max) && (value >= min);
        }
      };
    };
 
  protected:
    Element(uint8_t *ptr, size_t size);
 
  public:
    Element(const Element &other);
    virtual ~Element();
 
    Element &operator=(const Element &other);
 
    virtual bool isValid() const;
    virtual void clear();
 
    bool fill(uint8_t value, unsigned offset=0, int size=-1);
 
    bool getBit(const Offset::BitOffset &offset) const;
    bool getBit(unsigned offset, unsigned bit) const;
    void setBit(const Offset::BitOffset &offset, bool value=true);
    void setBit(unsigned offset, unsigned bit, bool value=true);
    void clearBit(unsigned offset, unsigned bit);
 
    uint8_t getUInt2(unsigned offset, unsigned bit) const;
    void setUInt2(unsigned offset, unsigned bit, uint8_t value);
 
    uint8_t getUInt3(unsigned offset, unsigned bit) const;
    void setUInt3(unsigned offset, unsigned bit, uint8_t value);
 
    uint8_t getUInt4(unsigned offset, unsigned bit) const;
    void setUInt4(unsigned offset, unsigned bit, uint8_t value);
 
    uint8_t getUInt5(unsigned offset, unsigned bit) const;
    void setUInt5(unsigned offset, unsigned bit, uint8_t value);
 
    uint8_t getUInt6(unsigned offset, unsigned bit) const;
    void setUInt6(unsigned offset, unsigned bit, uint8_t value);
 
    uint8_t getUInt8(unsigned offset) const;
    void setUInt8(unsigned offset, uint8_t value);
    int8_t getInt8(unsigned offset) const;
    void setInt8(unsigned offset, int8_t value);
 
    uint16_t getUInt16_be(unsigned offset) const;
    uint16_t getUInt16_le(unsigned offset) const;
    void setUInt16_be(unsigned offset, uint16_t value);
    void setUInt16_le(unsigned offset, uint16_t value);
 
    uint32_t getUInt24_be(unsigned offset) const;
    uint32_t getUInt24_le(unsigned offset) const;
    void setUInt24_be(unsigned offset, uint32_t value);
    void setUInt24_le(unsigned offset, uint32_t value);
 
    uint32_t getUInt32_be(unsigned offset) const;
    uint32_t getUInt32_le(unsigned offset) const;
    void setUInt32_be(unsigned offset, uint32_t value);
    void setUInt32_le(unsigned offset, uint32_t value);
 
    uint64_t getUInt64_be(unsigned offset) const;
    uint64_t getUInt64_le(unsigned offset) const;
    void setUInt64_be(unsigned offset, uint64_t value);
    void setUInt64_le(unsigned offset, uint64_t value);
 
    uint8_t getBCD2(unsigned offset) const;
    void setBCD2(unsigned offset, uint8_t value);
 
    uint16_t getBCD4_be(unsigned offset) const;
    void setBCD4_be(unsigned offset, uint16_t value);
    uint16_t getBCD4_le(unsigned offset) const;
    void setBCD4_le(unsigned offset, uint16_t value);
 
    uint32_t getBCD8_be(unsigned offset) const;
    void setBCD8_be(unsigned offset, uint32_t value);
    uint32_t getBCD8_le(unsigned offset) const;
    void setBCD8_le(unsigned offset, uint32_t value);
 
    QString readASCII(unsigned offset, unsigned maxlen, uint8_t eos=0x00) const;
    void writeASCII(unsigned offset, const QString &txt, unsigned maxlen, uint8_t eos=0x00);
 
    QString readUnicode(unsigned offset, unsigned maxlen, uint16_t eos=0x0000) const;
    void writeUnicode(unsigned offset, const QString &txt, unsigned maxlen, uint16_t eos=0x0000);
 
  protected:
    uint8_t *_data;
    size_t _size;
  };
 
  class Context
  {
  public:
    explicit Context(Config *config);
 
    Config *config() const;
 
    ConfigItem *obj(const QMetaObject *elementType, unsigned idx);
    int index(ConfigItem *obj);
    bool add(ConfigItem *obj, unsigned idx);
 
    bool addTable(const QMetaObject *obj);
    bool hasTable(const QMetaObject *obj) const;
 
    template <class T>
    T* get(unsigned idx) {
      return this->obj(&(T::staticMetaObject), idx)->template as<T>();
    }
 
    template <class T>
    bool has(unsigned idx) {
      return nullptr != this->obj(&(T::staticMetaObject), idx)->template as<T>();
    }
 
    template <class T>
    unsigned int count() {
      return getTable(&T::staticMetaObject).indices.size();
    }
 
  protected:
    class Table {
    public:
      QHash<unsigned, ConfigItem *> objects;
      QHash<ConfigItem *, unsigned> indices;
    };
 
  protected:
    Table &getTable(const QMetaObject *obj);
 
  protected:
    Config *_config;
    QHash<QString, Table> _tables;
  };
 
protected:
  explicit Codeplug(QObject *parent=nullptr);
 
public:
  virtual ~Codeplug();
 
  virtual bool index(Config *config, Context &ctx, const ErrorStack &err=ErrorStack()) const = 0;
 
  virtual bool decode(Config *config, const ErrorStack &err=ErrorStack()) = 0;
  virtual bool postprocess(Config *config, const ErrorStack &err=ErrorStack()) const;
 
  virtual Config *preprocess(Config *config, const ErrorStack &err=ErrorStack()) const;
  virtual bool encode(Config *config, const Flags &flags=Flags(), const ErrorStack &err=ErrorStack()) = 0;
};
 
#endif // CODEPLUG_HH