using RadioPacket;

Message m(arr, sizeof(arr));
m.setRawAction(UPDATE_DB_CMD);

RadioPacket p(&m);
p.setRawTransmitterId(TRANSMITTER_ID);
p.setRawReceiverId(RECEIVER_ID);
p.setRawCrc8(p.generateChecksum());

man.transmitArray(
    p.getRawPacketLength(),
    const_cast<uint8_t*>(p.getData()));

RadioPacket* p;
Message* m;

if(RadioPacket::parse(&p, buffer, BUFFER_SIZE) == RadioPacket::PARSE_OK) {
    if(Message::parse(&m, p->getBodyData(), p->getRawBodyLength()) == Message::PARSE_OK) {
        Serial.println(m->getBodyData());
    }
}

delete p;
delete m;

// MeasurementMessage.h

#include <RadioPacket.h>

/**
 * MeasurementMessage holds a single 16 bit integer
 */
class MeasurementMessage : public RadioPacket::Message {

protected:
    static const uint8_t _MEASUREMENT_OFFSET = 0;
    static const uint8_t _ACTION_VALUE = 1;

public:
    MeasurementMessage() : Message() {
        this->setRawAction(_ACTION_VALUE);
        this->resizeBody(sizeof(uint16_t));
    }

    uint16_t getMeasurement() const noexcept {
        return this->_data.getUInt16(this->fromBaseBodyOffset(
            _MEASUREMENT_OFFSET));
    }

    void setMeasurement(const uint16_t m) noexcept {
        this->_data.setUInt16(m, this->fromBaseBodyOffset(
            _MEASUREMENT_OFFSET));
    }

};

// example use of MeasurementMessage
// read analog value of A1 into message object
MeasurementMessage mm;
mm.setMeasurement(::analogRead(A1));

// then encapsulate the message into a RadioPacket as
// in the example transmitter code above

// when receiving, cast Message to a MeasurementMessage,
// where m is a Message* as in the example receiver code above
MeasurementMessage* mm = static_cast<MeasurementMessage*>(m);
mm->getMeasurement();