Moved enums and added Q_ENUM

src/modules/dns-base/includes/dns-base/QDnsBase.h

 #ifndef QDNSAGG_QDNSBASE_H
 #define QDNSAGG_QDNSBASE_H
 
+#include <QObject>
+
 namespace QDns
 {
     namespace Base
     {
-        /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-5 */
-        enum HeaderOpcode
+        class QDnsBase : public QObject
         {
-            Query = 0,
-            IQuery = 1,
-            Status = 2,
-            Notify = 4,
-            Update = 5
-        };
+            Q_OBJECT
+        public:
+            /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-5 */
+            enum HeaderOpcode
+            {
+                Query = 0,
+                IQuery = 1,
+                Status = 2,
+                Notify = 4,
+                Update = 5
+            };
+            Q_ENUM(HeaderOpcode)
 
-        /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6 */
-        enum HeaderReplyCode
-        {
-            NoError = 0,
-            FormErr = 1,
-            ServFail = 2,
-            NXDomain = 3,
-            NotImp = 4,
-            Refused = 5,
-            YXDomain = 6,
-            YXRRSet = 7,
-            NXRRSet = 8,
-            NotAuth = 9,
-            NotZone = 10,
-            BADVERS = 16, /* BADSIG */
-            BADKEY = 17,
-            BADTIME = 18,
-            BADMODE = 19,
-            BADNAME = 20,
-            BADALG = 21,
-            BADTRUNC = 22,
-            BADCOOKIE = 23,
-        };
+            /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6 */
+            enum HeaderReplyCode
+            {
+                NoError = 0,
+                FormErr = 1,
+                ServFail = 2,
+                NXDomain = 3,
+                NotImp = 4,
+                Refused = 5,
+                YXDomain = 6,
+                YXRRSet = 7,
+                NXRRSet = 8,
+                NotAuth = 9,
+                NotZone = 10,
+                BADVERS = 16, /* BADSIG */
+                BADKEY = 17,
+                BADTIME = 18,
+                BADMODE = 19,
+                BADNAME = 20,
+                BADALG = 21,
+                BADTRUNC = 22,
+                BADCOOKIE = 23,
+            };
+            Q_ENUM(HeaderReplyCode)
 
-        /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4 */
-        enum RecordType
-        {
-            A = 1,
-            NS = 2,
-            MD = 3,
-            MF = 4,
-            CNAME = 5,
-            SOA = 6,
-            MB = 7,
-            MG = 8,
-            MR = 9,
-            _NULL = 10,
-            WKS = 11,
-            PTR = 12,
-            HINFO = 13,
-            MINFO = 14,
-            MX = 15,
-            TXT = 16,
-            RP = 17,
-            AFSDB = 18,
-            X25 = 19,
-            ISDN = 20,
-            RT = 21,
-            NSAP = 22,
-            NSAPPTR = 23,
-            SIG = 24,
-            KEY = 25,
-            PX = 26,
-            GPOS = 27,
-            AAAA = 28,
-            LOC = 29,
-            NXT = 30,
-            EID = 31,
-            NIMLOC = 32,
-            SRV = 33,
-            ATMA = 34,
-            NAPTR = 35,
-            KX = 36,
-            CERT = 37,
-            A6 = 38,
-            DNAME = 39,
-            SINK = 40,
-            OPT = 41,
-            APL = 42,
-            DS = 43,
-            SSHFP = 44,
-            IPSECKEY = 45,
-            RRSIG = 46,
-            NSEC = 47,
-            DNSKEY = 48,
-            DHCID = 49,
-            NSEC3 = 50,
-            NSEC3PARAM = 51,
-            TLSA = 52,
-            SMIMEA = 53,
-            Unassigned = 54,
-            HIP = 55,
-            NINFO = 56,
-            RKEY = 57,
-            TALINK = 58,
-            CDS = 59,
-            CDNSKEY = 60,
-            OPENPGPKEY = 61,
-            CSYNC = 62,
-            SPF = 99,
-            UINFO = 100,
-            UID = 101,
-            GID = 102,
-            UNSPEC = 103,
-            NID = 104,
-            L32 = 105,
-            L64 = 106,
-            LP = 107,
-            EUI48 = 108,
-            EUI64 = 109,
-            TKEY = 249,
-            TSIG = 250,
-            IXFR = 251,
-            AXFR = 252,
-            MAILB = 253,
-            MAILA = 254,
-            ANY = 255,
-            URI = 256,
-            CAA = 257,
-            AVC = 258,
-            DOA = 259,
-            TA = 32768,
-            DLV = 32769
-        };
+            /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4 */
+            enum RecordType
+            {
+                A = 1,
+                NS = 2,
+                MD = 3,
+                MF = 4,
+                CNAME = 5,
+                SOA = 6,
+                MB = 7,
+                MG = 8,
+                MR = 9,
+                _NULL = 10,
+                WKS = 11,
+                PTR = 12,
+                HINFO = 13,
+                MINFO = 14,
+                MX = 15,
+                TXT = 16,
+                RP = 17,
+                AFSDB = 18,
+                X25 = 19,
+                ISDN = 20,
+                RT = 21,
+                NSAP = 22,
+                NSAPPTR = 23,
+                SIG = 24,
+                KEY = 25,
+                PX = 26,
+                GPOS = 27,
+                AAAA = 28,
+                LOC = 29,
+                NXT = 30,
+                EID = 31,
+                NIMLOC = 32,
+                SRV = 33,
+                ATMA = 34,
+                NAPTR = 35,
+                KX = 36,
+                CERT = 37,
+                A6 = 38,
+                DNAME = 39,
+                SINK = 40,
+                OPT = 41,
+                APL = 42,
+                DS = 43,
+                SSHFP = 44,
+                IPSECKEY = 45,
+                RRSIG = 46,
+                NSEC = 47,
+                DNSKEY = 48,
+                DHCID = 49,
+                NSEC3 = 50,
+                NSEC3PARAM = 51,
+                TLSA = 52,
+                SMIMEA = 53,
+                Unassigned = 54,
+                HIP = 55,
+                NINFO = 56,
+                RKEY = 57,
+                TALINK = 58,
+                CDS = 59,
+                CDNSKEY = 60,
+                OPENPGPKEY = 61,
+                CSYNC = 62,
+                SPF = 99,
+                UINFO = 100,
+                UID = 101,
+                GID = 102,
+                UNSPEC = 103,
+                NID = 104,
+                L32 = 105,
+                L64 = 106,
+                LP = 107,
+                EUI48 = 108,
+                EUI64 = 109,
+                TKEY = 249,
+                TSIG = 250,
+                IXFR = 251,
+                AXFR = 252,
+                MAILB = 253,
+                MAILA = 254,
+                ANY = 255,
+                URI = 256,
+                CAA = 257,
+                AVC = 258,
+                DOA = 259,
+                TA = 32768,
+                DLV = 32769
+            };
+            Q_ENUM(RecordType)
 
-        /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-2 */
-        enum RecordClass
-        {
-            IN = 1,
-            CH = 3,
-            HS = 4,
-            QCLASSNONE = 254,
-            QCLASSANY = 255
+            /* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-2 */
+            enum RecordClass
+            {
+                IN = 1,
+                CH = 3,
+                HS = 4,
+                QCLASSNONE = 254,
+                QCLASSANY = 255
+            };
+            Q_ENUM(RecordClass)
         };
     }
 }

src/modules/dns-base/includes/dns-base/QDnsHeader.h

 
             void setIsQuery(bool isQuery);
 
-            HeaderOpcode getOpcode() const;
+            QDnsBase::HeaderOpcode getOpcode() const;
 
-            void setOpcode(HeaderOpcode opcode);
+            void setOpcode(QDnsBase::HeaderOpcode opcode);
 
             bool isAuthoritative() const;
 
 
             void setNonAuthenticatedAcceptable(bool isNonAuthenticatedAcceptable);
 
-            HeaderReplyCode getReplyCode() const;
+            QDnsBase::HeaderReplyCode getReplyCode() const;
 
-            void setReplyCode(HeaderReplyCode replyCode);
+            void setReplyCode(QDnsBase::HeaderReplyCode replyCode);
 
 
             quint16 getQueryCount() const;

src/modules/dns-base/includes/dns-base/QDnsPacket.h

 
             void setAdditionalRecords(const QList<QDnsResourceRecord> &additionalRecords);
 
-            static QDnsPacket makeSimpleQuery(const QString& host, RecordType type);
+            static QDnsPacket makeSimpleQuery(const QString& host, QDnsBase::RecordType type);
 
         private:
             void parse(const QByteArray &data, QDataStream &dataStream);

src/modules/dns-base/includes/dns-base/QDnsQuery.h

 
             void setName(const QString &name);
 
-            RecordType getType() const;
+            QDnsBase::RecordType getType() const;
 
-            void setType(RecordType type);
+            void setType(QDnsBase::RecordType type);
 
-            RecordClass getClass() const;
+            QDnsBase::RecordClass getClass() const;
 
-            void setClass(RecordClass aClass);
+            void setClass(QDnsBase::RecordClass aClass);
 
         private:
             void parse(const QByteArray &packetData, QDataStream &dataStream);

src/modules/dns-base/src/QDnsHeader.cpp

             setFlagBits(0, (quint8) !isQuery, 1);
         }
 
-        HeaderOpcode QDnsHeader::getOpcode() const
+        QDnsBase::HeaderOpcode QDnsHeader::getOpcode() const
         {
-            return (HeaderOpcode) getFlagBits(4, 4);
+            return (QDnsBase::HeaderOpcode) getFlagBits(4, 4);
         }
 
-        void QDnsHeader::setOpcode(HeaderOpcode opcode)
+        void QDnsHeader::setOpcode(QDnsBase::HeaderOpcode opcode)
         {
             setFlagBits(4, (quint8) opcode, 4);
         }
             setFlagBits(11, (quint8) isNonAuthenticatedAcceptable, 1);
         }
 
-        HeaderReplyCode QDnsHeader::getReplyCode() const
+        QDnsBase::HeaderReplyCode QDnsHeader::getReplyCode() const
         {
-            return (HeaderReplyCode) getFlagBits(15, 4);
+            return (QDnsBase::HeaderReplyCode) getFlagBits(15, 4);
         }
 
-        void QDnsHeader::setReplyCode(HeaderReplyCode replyCode)
+        void QDnsHeader::setReplyCode(QDnsBase::HeaderReplyCode replyCode)
         {
             setFlagBits(15, (quint8) replyCode, 4);
         }

src/modules/dns-base/src/QDnsPacket.cpp

             m_header.setAdditionalCount((quint16) m_additionalRecords.length());
         }
 
-        QDnsPacket QDnsPacket::makeSimpleQuery(const QString& host, RecordType type)
+        QDnsPacket QDnsPacket::makeSimpleQuery(const QString& host, QDnsBase::RecordType type)
         {
             QDns::Base::QDnsPacket packet;
             auto header = packet.getHeader();
             packet.setHeader(header);
             QDns::Base::QDnsQuery query;
             query.setName(host);
-            query.setClass(QDns::Base::RecordClass::IN);
+            query.setClass(QDns::Base::QDnsBase::RecordClass::IN);
             query.setType(type);
             packet.setQueries(QList<QDns::Base::QDnsQuery>() << query);
             return packet;

src/modules/dns-base/src/QDnsQuery.cpp

     {
         QDnsQuery::QDnsQuery()
                 : m_isValid(true)
-                  , m_type(RecordType::A)
-                  , m_class(RecordClass::IN)
+                  , m_type(QDnsBase::RecordType::A)
+                  , m_class(QDnsBase::RecordClass::IN)
         {
         }
 
             m_name = name;
         }
 
-        RecordType QDnsQuery::getType() const
+        QDnsBase::RecordType QDnsQuery::getType() const
         {
-            return (RecordType) m_type;
+            return (QDnsBase::RecordType) m_type;
         }
 
-        void QDnsQuery::setType(RecordType type)
+        void QDnsQuery::setType(QDnsBase::RecordType type)
         {
             m_type = type;
         }
 
-        RecordClass QDnsQuery::getClass() const
+        QDnsBase::RecordClass QDnsQuery::getClass() const
         {
-            return (RecordClass) m_class;
+            return (QDnsBase::RecordClass) m_class;
         }
 
-        void QDnsQuery::setClass(RecordClass aClass)
+        void QDnsQuery::setClass(QDnsBase::RecordClass aClass)
         {
             m_class = aClass;
         }

src/modules/dns-base/tests/DnsHeader.cpp

 
     quint16 flags;
     bool flagQuery;
-    QDns::Base::HeaderOpcode flagOpcode;
+    QDns::Base::QDnsBase::HeaderOpcode flagOpcode;
     bool flagAuthoritative;
     bool flagTruncated;
     bool flagRecursionDesired;
     bool flagReserved0;
     bool flagAnswerAuthenticated;
     bool flagNonAuthenticatedAcceptable;
-    QDns::Base::HeaderReplyCode flagReplyCode;
+    QDns::Base::QDnsBase::HeaderReplyCode flagReplyCode;
 
     quint16 queryCount;
     quint16 answerCount;
 
                                                      0x0100,
                                                      true,
-                                                     QDns::Base::HeaderOpcode::Query,
+                                                     QDns::Base::QDnsBase::HeaderOpcode::Query,
                                                      false,
                                                      false,
                                                      true,
                                                      false,
                                                      false,
                                                      false,
-                                                     QDns::Base::HeaderReplyCode::NoError,
+                                                     QDns::Base::QDnsBase::HeaderReplyCode::NoError,
 
                                                      1,
                                                      0,
                                                      0x3cdc,
                                                      0x8180,
                                                      false,
-                                                     QDns::Base::HeaderOpcode::Query,
+                                                     QDns::Base::QDnsBase::HeaderOpcode::Query,
                                                      false,
                                                      false,
                                                      true,
                                                      false,
                                                      false,
                                                      false,
-                                                     QDns::Base::HeaderReplyCode::NoError,
+                                                     QDns::Base::QDnsBase::HeaderReplyCode::NoError,
 
                                                      1,
                                                      1,
                                                      0x3cdc,
                                                      0xaaaa,
                                                      false,
-                                                     QDns::Base::HeaderOpcode::Update,
+                                                     QDns::Base::QDnsBase::HeaderOpcode::Update,
                                                      false,
                                                      true,
                                                      false,
                                                      false,
                                                      true,
                                                      false,
-                                                     QDns::Base::HeaderReplyCode::NotZone,
+                                                     QDns::Base::QDnsBase::HeaderReplyCode::NotZone,
 
                                                      43690,
                                                      21845,
                                                      0x3cdc,
                                                      0x5555,
                                                      true,
-                                                     (QDns::Base::HeaderOpcode) 10,
+                                                     (QDns::Base::QDnsBase::HeaderOpcode) 10,
                                                      true,
                                                      false,
                                                      true,
                                                      true,
                                                      false,
                                                      true,
-                                                     QDns::Base::HeaderReplyCode::Refused,
+                                                     QDns::Base::QDnsBase::HeaderReplyCode::Refused,
 
                                                      22015,
                                                      43690,

src/modules/dns-base/tests/DnsQuery.cpp

     const char* hexData;
 
     const char* name;
-    QDns::Base::RecordType type;
-    QDns::Base::RecordClass clazz;
+    QDns::Base::QDnsBase::RecordType type;
+    QDns::Base::QDnsBase::RecordClass clazz;
 };
 
 class DnsQuerySerializeTest : public ::testing::TestWithParam<DnsQuerySerializeTestParams>
                         ::testing::Values(
                                 DnsQuerySerializeTestParams {"0266720000020004",
                                                              "fr",
-                                                             QDns::Base::RecordType::NS,
-                                                             QDns::Base::RecordClass::HS
+                                                             QDns::Base::QDnsBase::RecordType::NS,
+                                                             QDns::Base::QDnsBase::RecordClass::HS
                                 },
                                 DnsQuerySerializeTestParams {"06676f6f676c650266720000010001",
                                                              "google.fr",
-                                                             QDns::Base::RecordType::A,
-                                                             QDns::Base::RecordClass::IN
+                                                             QDns::Base::QDnsBase::RecordType::A,
+                                                             QDns::Base::QDnsBase::RecordClass::IN
                                 },
                                 DnsQuerySerializeTestParams {"03777777067274686f6e6903636f6d0000010001",
                                                              "www.rthoni.com",
-                                                             QDns::Base::RecordType::A,
-                                                             QDns::Base::RecordClass::IN
+                                                             QDns::Base::QDnsBase::RecordType::A,
+                                                             QDns::Base::QDnsBase::RecordClass::IN
                                 }
                         ));