Correction by review. Adding attribute types to dictionaries.

include/radproto/attribute.h

@@ -10,21 +10,21 @@ namespace RadProto
     class Attribute
     {
         public:
-            Attribute(uint8_t type);
+            Attribute(uint8_t code);
             virtual ~Attribute() = default;
-            uint8_t type() const { return m_type; }
+            uint8_t code() const { return m_code; }
             virtual std::string toString() const = 0;
             virtual std::vector<uint8_t> toVector(const std::string& secret, const std::array<uint8_t, 16>& auth) const = 0;
             virtual Attribute* clone() const = 0;
         private:
-            uint8_t m_type;
+            uint8_t m_code;
     };
 
     class String: public Attribute
     {
         public:
-            String(uint8_t type, const uint8_t* data, size_t size);
-            String(uint8_t type, const std::string& string);
+            String(uint8_t code, const uint8_t* data, size_t size);
+            String(uint8_t code, const std::string& string);
             std::string toString() const override { return m_value; }
             std::vector<uint8_t> toVector(const std::string& secret, const std::array<uint8_t, 16>& auth) const override;
             String* clone() const override;
@@ -35,8 +35,8 @@ namespace RadProto
     class Integer: public Attribute
     {
         public:
-            Integer(uint8_t type, const uint8_t* data, size_t size);
-            Integer(uint8_t type, uint32_t value);
+            Integer(uint8_t code, const uint8_t* data, size_t size);
+            Integer(uint8_t code, uint32_t value);
             std::string toString() const override;
             std::vector<uint8_t> toVector(const std::string& secret, const std::array<uint8_t, 16>& auth) const override;
             Integer* clone() const override;
@@ -47,8 +47,8 @@ namespace RadProto
     class IpAddress : public Attribute
     {
         public:
-            IpAddress(uint8_t type, const uint8_t* data, size_t size);
-            IpAddress(uint8_t type, const std::array<uint8_t, 4>& address);
+            IpAddress(uint8_t code, const uint8_t* data, size_t size);
+            IpAddress(uint8_t code, const std::array<uint8_t, 4>& address);
             std::string toString() const override;
             std::vector<uint8_t> toVector(const std::string& secret, const std::array<uint8_t, 16>& auth) const override;
             IpAddress* clone() const override;
@@ -59,8 +59,8 @@ namespace RadProto
     class Encrypted : public Attribute
     {
         public:
-            Encrypted (uint8_t type, const uint8_t* data, size_t size, const std::string& secret, const std::array<uint8_t, 16>& auth);
-            Encrypted(uint8_t type, const std::string& password);
+            Encrypted (uint8_t code, const uint8_t* data, size_t size, const std::string& secret, const std::array<uint8_t, 16>& auth);
+            Encrypted(uint8_t code, const std::string& password);
             std::string toString() const override { return m_value; }
             std::vector<uint8_t> toVector(const std::string& secret, const std::array<uint8_t, 16>& auth) const override;
             Encrypted* clone() const override;
@@ -71,8 +71,8 @@ namespace RadProto
     class Bytes: public Attribute
     {
         public:
-            Bytes(uint8_t type, const uint8_t* data, size_t size);
-            Bytes(uint8_t type, const std::vector<uint8_t>& bytes);
+            Bytes(uint8_t code, const uint8_t* data, size_t size);
+            Bytes(uint8_t code, const std::vector<uint8_t>& bytes);
             std::string toString() const override;
             std::vector<uint8_t> toVector(const std::string& secret, const std::array<uint8_t, 16>& auth) const override;
             Bytes* clone() const override;
@@ -83,8 +83,8 @@ namespace RadProto
     class ChapPassword: public Attribute
     {
         public:
-            ChapPassword(uint8_t type, const uint8_t* data, size_t size);
-            ChapPassword(uint8_t type, uint8_t chapId, const std::vector<uint8_t>& chapValue);
+            ChapPassword(uint8_t code, const uint8_t* data, size_t size);
+            ChapPassword(uint8_t code, uint8_t chapId, const std::vector<uint8_t>& chapValue);
             std::string toString() const override;
             uint8_t chapId() const { return m_chapId; }
             std::vector<uint8_t> chapValue() const { return m_value; }

include/radproto/attribute_types.h → include/radproto/attribute_codes.h

@@ -2,7 +2,7 @@
 
 namespace RadProto
 {
-    enum Attribute_Types
+    enum Attribute_Codes
     {
         USER_NAME = 1,
         USER_PASSWORD = 2,

include/radproto/dictionaries.h

@@ -12,8 +12,25 @@ namespace RadProto
             BasicDictionary() = default;
             std::string name(uint32_t code) const;
             uint32_t code(const std::string& name) const;
-            void add(uint32_t code, const std::string& name);
+            std::string type(uint32_t code) const;
+            std::string type(const std::string& name) const;
+
+            void add(uint32_t code, const std::string& name, const std::string& type);
             void append(const BasicDictionary& basicDict);
+        private:
+            std::map<uint32_t, std::pair<std::string, std::string>> m_rightDict;
+            std::map<std::string, std::pair<uint32_t, std::string>> m_reverseDict;
+    };
+
+    class VendorDictionary
+    {
+        public:
+            VendorDictionary() = default;
+            std::string name(uint32_t code) const;
+            uint32_t code(const std::string& name) const;
+
+            void add(uint32_t code, const std::string& name);
+            void append(const VendorDictionary& vendorDict);
         private:
             std::map<uint32_t, std::string> m_rightDict;
             std::map<std::string, uint32_t> m_reverseDict;
@@ -38,13 +55,15 @@ namespace RadProto
             Dictionaries(const std::string& filePath);
             void append(const Dictionaries& fillingDictionaries);
             const BasicDictionary& attributes() const { return m_attributes; }
-            const BasicDictionary& vendorNames() const { return m_vendorNames; }
+            const VendorDictionary& vendorNames() const { return m_vendorNames; }
             const DependentDictionary& attributeValues() const { return m_attributeValues; }
             const DependentDictionary& vendorAttributes() const { return m_vendorAttributes; }
             const DependentDictionary& vendorAttributeValues() const { return m_vendorAttributeValues; }
 
             std::string attributeName(uint32_t code) const;
             uint32_t attributeCode(const std::string& name) const;
+            std::string attributeType(uint32_t code) const;
+            std::string attributeType(const std::string name) const;
 
             std::string vendorName(uint32_t code) const;
             uint32_t vendorCode(const std::string& name) const;
@@ -60,7 +79,7 @@ namespace RadProto
 
         private:
             BasicDictionary m_attributes;
-            BasicDictionary m_vendorNames;
+            VendorDictionary m_vendorNames;
             DependentDictionary m_attributeValues;
             DependentDictionary m_vendorAttributes;
             DependentDictionary m_vendorAttributeValues;

include/radproto/error.h

@@ -19,11 +19,12 @@ namespace RadProto
         numberOfBytesIsLessThan20,
         requestLengthIsShort,
         eapMessageAttributeError,
-        invalidAttributeType,
+        invalidAttributeCode,
         invalidAttributeSize,
         invalidVendorSpecificAttributeId,
         suchAttributeNameAlreadyExists,
-        suchAttributeCodeAlreadyExists
+        suchAttributeCodeAlreadyExists,
+        suchAttributeNameWithAnotherTypeAlreadyExists
     };
 
     class Exception: public std::runtime_error

include/radproto/packet.h

@@ -13,18 +13,18 @@ namespace RadProto
     {
         public:
             Packet(const uint8_t* buffer, size_t size, const std::string& secret);
-            Packet(uint8_t type, uint8_t id, const std::array<uint8_t, 16>& auth, const std::vector<Attribute*>& attributes, const std::vector<VendorSpecific>& vendorSpecific);
+            Packet(uint8_t code, uint8_t id, const std::array<uint8_t, 16>& auth, const std::vector<Attribute*>& attributes, const std::vector<VendorSpecific>& vendorSpecific);
             Packet(const Packet& other);
             ~Packet();
-            uint8_t type() const { return m_type; }
+            uint8_t code() const { return m_code; }
             uint8_t id() const { return m_id; };
             const std::array<uint8_t, 16>& auth() const { return m_auth; }
             const std::vector<Attribute*>& attributes() const { return m_attributes; }
             const std::vector<VendorSpecific>& vendorSpecific() const { return m_vendorSpecific; }
             const std::vector<uint8_t> makeSendBuffer(const std::string& secret) const;
 
         private:
-            uint8_t m_type;
+            uint8_t m_code;
             uint8_t m_id;
             bool m_recalcAuth;
             std::array<uint8_t, 16> m_auth;

include/radproto/vendor_attribute.h

@@ -10,14 +10,14 @@ namespace RadProto
     {
         public:
             VendorSpecific(const uint8_t* data);
-            VendorSpecific(uint32_t vendorId, uint8_t vendorType, const std::vector<uint8_t>& vendorValue);
+            VendorSpecific(uint32_t vendorId, uint8_t vendorAttributeCode, const std::vector<uint8_t>& vendorValue);
             std::string toString() const;
-            uint8_t vendorType() const { return m_vendorType; }
+            uint8_t vendorAttributeCode() const { return m_vendorAttributeCode; }
             uint32_t vendorId() const { return m_vendorId; }
             std::vector<uint8_t> toVector() const;
         private:
             uint32_t m_vendorId;
-            uint8_t m_vendorType;
+            uint8_t m_vendorAttributeCode;
             std::vector<uint8_t> m_value;
     };
 }

sample/server.cpp

@@ -1,6 +1,6 @@
 #include "server.h"
 #include "packet_codes.h"
-#include "attribute_types.h"
+#include "attribute_codes.h"
 #include <functional>
 #include <iostream>
 
@@ -37,11 +37,11 @@ RadProto::Packet Server::makeResponse(const RadProto::Packet& request)
     std::string userName;
     for (const auto& attribute : request.attributes())
     {
-        if (attribute->type() == RadProto::USER_NAME)
+        if (attribute->code() == RadProto::USER_NAME)
             userName = attribute->toString();
     }
 
-    if (request.type() == RadProto::ACCESS_REQUEST && userName == "test")
+    if (request.code() == RadProto::ACCESS_REQUEST && userName == "test")
         return RadProto::Packet(RadProto::ACCESS_ACCEPT, request.id(), request.auth(), attributes, vendorSpecific);
 
     return RadProto::Packet(RadProto::ACCESS_REJECT, request.id(), request.auth(), attributes, vendorSpecific);