codeplug.hh

#ifndef CODEPLUG_HH
#define CODEPLUG_HH
 
#include <QObject>
#include <QHash>
#include "dfufile.hh"
#include "transferflags.hh"
 
class Config;
class ConfigItem;
class SatelliteDatabase;
 

class Codeplug: public DFUFile
{
  Q_OBJECT
 
public:
  class Flags: public TransferFlags {
  public:
    Flags();
 
  public:
    bool updateCodeplug() const;
    void setUpdateCodeplug(bool enable);

    bool autoEnableGPS() const;
    void setAutoEnableGPS(bool enable);

    bool autoEnableRoaming() const;
    void setAutoEnableRoaming(bool enable);
 
  protected:
    bool _updateCodeplug;
    bool _autoEnableGPS;
    bool _autoEnableRoaming;
  };
 

  class Element
  {
  protected:
    struct Offset {
      struct Bit {
        const unsigned int byte;
        const unsigned int bit;

        inline Bit operator+ (unsigned int bits) const {
          unsigned int tmp = 8 * byte + (7-bit) + bits;
          return {tmp/8, (7 - (tmp % 8))};
        }

        inline Bit operator- (unsigned int bits) const {
          unsigned int tmp = 8 * byte + (7-bit) - bits;
          return {tmp/8, (7 - (tmp % 8))};
        }
      };
    };
 
  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);
        }

        inline T mapTo(const Range<T> &other, const T &value) const {
          T myD = max-min, oD = other.max-other.min;
          return ((limit(value)-min)*oD)/myD + other.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::Bit &offset) const;
    bool getBit(unsigned offset, unsigned bit) const;
    void setBit(const Offset::Bit &offset, bool value=true);
    void setBit(unsigned offset, unsigned bit, bool value=true);
    void clearBit(unsigned offset, unsigned bit);
    void clearBit(const Offset::Bit &offset);

    uint8_t getUInt2(const Offset::Bit &offset) const;
    uint8_t getUInt2(unsigned offset, unsigned bit) const;
    void setUInt2(const Offset::Bit &offset, uint8_t value);
    void setUInt2(unsigned offset, unsigned bit, uint8_t value);

    uint8_t getUInt3(const Offset::Bit &offset) const;
    uint8_t getUInt3(unsigned offset, unsigned bit) const;
    void setUInt3(const Offset::Bit &offset, uint8_t value);
    void setUInt3(unsigned offset, unsigned bit, uint8_t value);

    uint8_t getUInt4(const Offset::Bit &offset) const;
    uint8_t getUInt4(unsigned offset, unsigned bit) const;
    void setUInt4(const Offset::Bit &offset, uint8_t value);
    void setUInt4(unsigned offset, unsigned bit, uint8_t value);

    uint8_t getUInt5(const Offset::Bit &offset) const;
    uint8_t getUInt5(unsigned offset, unsigned bit) const;
    void setUInt5(const Offset::Bit &offset, uint8_t value);
    void setUInt5(unsigned offset, unsigned bit, uint8_t value);

    uint8_t getUInt6(const Offset::Bit &offset) const;
    uint8_t getUInt6(unsigned offset, unsigned bit) const;
    void setUInt6(const Offset::Bit &offset, uint8_t value);
    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;

    SatelliteDatabase *satellites() 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;
    SatelliteDatabase *_satellites;
    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