Adding new functions to Dictionaries.

include/radproto/dictionaries.h

@@ -17,6 +17,8 @@ namespace RadProto
 
             void add(uint32_t code, const std::string& name, const std::string& type);
             void append(const BasicDictionary& basicDict);
+            bool findByName(const std::string& name) const;
+            bool findByCode(uint32_t code) const;
         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;
@@ -31,7 +33,9 @@ namespace RadProto
 
             void add(uint32_t code, const std::string& name);
             void append(const VendorDictionary& vendorDict);
-        private:
+            bool findByName(const std::string& name) const;
+            bool findByCode(uint32_t code) const;
+       private:
             std::map<uint32_t, std::string> m_rightDict;
             std::map<std::string, uint32_t> m_reverseDict;
     };
@@ -44,6 +48,8 @@ namespace RadProto
             uint32_t code(const std::string& dependencyName, const std::string& name) const;
             void add(uint32_t code, const std::string& name, const std::string& dependencyName);
             void append(const DependentDictionary& dependentDict);
+            bool findByName(const std::string& dependencyName, const std::string& name) const;
+            bool findByCode(const std::string& dependencyName, uint32_t code) const;
         private:
             std::map<std::pair<std::string, uint32_t>, std::string> m_rightDict;
             std::map<std::pair<std::string, std::string>, uint32_t> m_reverseDict;
@@ -63,17 +69,24 @@ namespace RadProto
             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 attributeType(const std::string& name) const;
+            bool attributeFindByName(const std::string& name) const;
+            bool attributeFindByCode(uint32_t) const;
 
             std::string vendorName(uint32_t code) const;
             uint32_t vendorCode(const std::string& name) const;
+            bool vendorFindByName(const std::string& name) const;
+            bool vendorFindByCode(uint32_t) const;
 
             std::string vendorAttributeName(const std::string& vendorName, uint32_t code) const;
             uint32_t vendorAttributeCode(const std::string& vendorName, const std::string& name) const;
 
             std::string attributeValueName(const std::string& attributeName, uint32_t code) const;
             uint32_t attributeValueCode(const std::string& attributeName, const std::string& name) const;
 
+            bool attributeValueFindByName(const std::string& attributeName, const std::string& name) const;
+            bool attributeValueFindByCode(const std::string& attributeName, uint32_t code) const;
+
             std::string vendorAttributeValueName(const std::string& valueName, uint32_t code) const;
             uint32_t vendorAttributeValueCode(const std::string& valueName, const std::string& name) const;
 

src/attribute.cpp

@@ -58,16 +58,18 @@ Attribute* Attribute::make(uint8_t code, const std::string& type, const std::str
             return new Encrypted(code, data);
         case ValueType::IpAddress:
         {
-            using tokenizer =  boost::tokenizer<boost::char_separator<char>>;
-            boost::char_separator<char> sep(".");
-            tokenizer tok(data, sep);
-
             std::array<uint8_t, 4> ipAddr;
-            size_t i = 0;
-            for (const auto& t : tok)
+            if (data == "0")
+                ipAddr = {0};
+            else
             {
-                ipAddr[i] = static_cast<uint8_t>(std::stoul(t));
-                ++i;
+                using tokenizer =  boost::tokenizer<boost::char_separator<char>>;
+                boost::char_separator<char> sep(".");
+                tokenizer tok(data, sep);
+
+                size_t i = 0;
+                for (const auto& t : tok)
+                    ipAddr[i++] = static_cast<uint8_t>(std::stoul(t));
             }
             return new IpAddress(code, ipAddr);
         }

src/dictionaries.cpp

@@ -52,6 +52,16 @@ void BasicDictionary::append(const BasicDictionary& basicDict)
         m_reverseDict.insert_or_assign(entry.first, entry.second);
 }
 
+bool BasicDictionary::findByName(const std::string& name) const
+{
+    return m_reverseDict.count(name) > 0;
+}
+
+bool BasicDictionary::findByCode(uint32_t code) const
+{
+    return m_rightDict.count(code) > 0;
+}
+
 using VendorDictionary = RadProto::VendorDictionary;
 
 std::string VendorDictionary::name(uint32_t code) const
@@ -90,6 +100,16 @@ void VendorDictionary::append(const VendorDictionary& vendorDict)
         m_reverseDict.emplace(entry.first, entry.second);
 }
 
+bool VendorDictionary::findByName(const std::string& name) const
+{
+    return m_reverseDict.count(name) > 0;
+}
+
+bool VendorDictionary::findByCode(uint32_t code) const
+{
+    return m_rightDict.count(code) > 0;
+}
+
 using DependentDictionary = RadProto::DependentDictionary;
 
 std::string DependentDictionary::name(const std::string& dependencyName, uint32_t code) const
@@ -127,6 +147,16 @@ void DependentDictionary::append(const DependentDictionary& dependentDict)
         m_reverseDict.insert_or_assign(entry.first, entry.second);
 }
 
+bool DependentDictionary::findByName(const std::string& dependencyName, const std::string& name) const
+{
+    return m_reverseDict.count({dependencyName, name}) > 0;
+}
+
+bool DependentDictionary::findByCode(const std::string& dependencyName, uint32_t code) const
+{
+    return m_rightDict.count({dependencyName, code}) > 0;
+}
+
 using Dictionaries = RadProto::Dictionaries;
 
 Dictionaries::Dictionaries(const std::string& filePath)
@@ -246,11 +276,21 @@ std::string Dictionaries::attributeType(uint32_t code) const
     return attributes().type(code);
 }
 
-std::string Dictionaries::attributeType(const std::string name) const
+std::string Dictionaries::attributeType(const std::string& name) const
 {
     return attributes().type(name);
 }
 
+bool Dictionaries::attributeFindByName(const std::string& name) const
+{
+    return attributes().findByName(name);
+}
+
+bool Dictionaries::attributeFindByCode(uint32_t code) const
+{
+    return attributes().findByCode(code);
+}
+
 std::string Dictionaries::vendorName(uint32_t code) const
 {
     return vendorNames().name(code);
@@ -261,6 +301,16 @@ uint32_t Dictionaries::vendorCode(const std::string& name) const
     return vendorNames().code(name);
 }
 
+bool Dictionaries::vendorFindByName(const std::string& name) const
+{
+    return vendorNames().findByName(name);
+}
+
+bool Dictionaries::vendorFindByCode(uint32_t code) const
+{
+    return vendorNames().findByCode(code);
+}
+
 std::string Dictionaries::vendorAttributeName(const std::string& vendorName, uint32_t code) const
 {
     return vendorAttributes().name(vendorName, code);
@@ -281,6 +331,16 @@ uint32_t Dictionaries::attributeValueCode(const std::string& attributeName, cons
     return attributeValues().code(attributeName, name);
 }
 
+bool Dictionaries::attributeValueFindByName(const std::string& attributeName, const std::string& name) const
+{
+    return attributeValues().findByName(attributeName, name);
+}
+
+bool Dictionaries::attributeValueFindByCode(const std::string& attributeName, uint32_t code) const
+{
+    return attributeValues().findByCode(attributeName, code);
+}
+
 std::string Dictionaries::vendorAttributeValueName(const std::string& valueName, uint32_t code) const
 {
     return vendorAttributeValues().name(valueName, code);

tests/dictionaries_tests.cpp

@@ -246,6 +246,19 @@ BOOST_AUTO_TEST_CASE(TestAppend)
     BOOST_CHECK_EQUAL(j.type("abc"), "integer");
 }
 
+BOOST_AUTO_TEST_CASE(TestsFindByNameAndFindByCode)
+{
+    RadProto::BasicDictionary b;
+
+    b.add(1, "abc", "string");
+
+    BOOST_CHECK_EQUAL(b.findByName("abc"), true);
+    BOOST_CHECK_EQUAL(b.findByName("def"), false);
+
+    BOOST_CHECK_EQUAL(b.findByCode(1), true);
+    BOOST_CHECK_EQUAL(b.findByCode(2), false);
+}
+
 BOOST_AUTO_TEST_CASE(TestConstructor)
 {
     RadProto::BasicDictionary b;
@@ -600,6 +613,19 @@ BOOST_AUTO_TEST_CASE(TestAppend)
     BOOST_CHECK_EQUAL(a.code("jkl"), 4);
 }
 
+BOOST_AUTO_TEST_CASE(TestsFindByNameAndFindByCode)
+{
+    RadProto::VendorDictionary b;
+
+    b.add(1, "Vendor-Name");
+
+    BOOST_CHECK_EQUAL(b.findByName("Vendor-Name"), true);
+    BOOST_CHECK_EQUAL(b.findByName("Name"), false);
+
+    BOOST_CHECK_EQUAL(b.findByCode(1), true);
+    BOOST_CHECK_EQUAL(b.findByCode(2), false);
+}
+
 BOOST_AUTO_TEST_CASE(TestConstructor)
 {
     RadProto::VendorDictionary b;
@@ -776,6 +802,19 @@ BOOST_AUTO_TEST_CASE(TestAppend)
     BOOST_CHECK_EQUAL(a.code("Service-Type", "Call-Check"), 10);
 }
 
+BOOST_AUTO_TEST_CASE(TestsFindByNameAndFindByCode)
+{
+    RadProto::DependentDictionary b;
+
+    b.add(2, "Framed-User", "Service-Type");
+
+    BOOST_CHECK_EQUAL(b.findByName("Service-Type", "Framed-User"), true);
+    BOOST_CHECK_EQUAL(b.findByName("Service-Type", "Name"), false);
+
+    BOOST_CHECK_EQUAL(b.findByCode("Service-Type", 2), true);
+    BOOST_CHECK_EQUAL(b.findByCode("Service-Type", 3), false);
+}
+
 BOOST_AUTO_TEST_CASE(TestConstructor)
 {
     RadProto::DependentDictionary b;
@@ -862,6 +901,17 @@ BOOST_AUTO_TEST_CASE(TestAttributeType)
     BOOST_CHECK_EQUAL(a.attributeType("abc"), "bytes");
 }
 
+BOOST_AUTO_TEST_CASE(TestsAttributeFindByNameAndAttributeFindByCode)
+{
+    RadProto::Dictionaries a("dictionary");
+
+    BOOST_CHECK_EQUAL(a.attributeFindByName("User-Name"), true);
+    BOOST_CHECK_EQUAL(a.attributeFindByName("Name"), false);
+
+    BOOST_CHECK_EQUAL(a.attributeFindByCode(1), true);
+    BOOST_CHECK_EQUAL(a.attributeFindByCode(3), false);
+}
+
 BOOST_AUTO_TEST_CASE(TestAttributeValueName)
 {
     RadProto::Dictionaries a("dictionary");
@@ -876,6 +926,17 @@ BOOST_AUTO_TEST_CASE(TestAttributeValueCode)
     BOOST_CHECK_EQUAL(a.attributeValueCode("Service-Type", "Framed-User"), 2);
 }
 
+BOOST_AUTO_TEST_CASE(TestsAttributeValueFindByNameAndAttributeValueFindByCode)
+{
+    RadProto::Dictionaries a("dictionary");
+
+    BOOST_CHECK_EQUAL(a.attributeValueFindByName("Service-Type","Framed-User"), true);
+    BOOST_CHECK_EQUAL(a.attributeValueFindByName("Service-Type", "Framed"), false);
+
+    BOOST_CHECK_EQUAL(a.attributeValueFindByCode("Service-Type", 2), true);
+    BOOST_CHECK_EQUAL(a.attributeValueFindByCode("Service-Type", 3), false);
+}
+
 BOOST_AUTO_TEST_CASE(TestVendorName)
 {
     RadProto::Dictionaries a("dictionary");
@@ -890,6 +951,17 @@ BOOST_AUTO_TEST_CASE(TestVendorCode)
     BOOST_CHECK_EQUAL(a.vendorCode("Dlink"), 171);
 }
 
+BOOST_AUTO_TEST_CASE(TestsVendorFindByNameAndVendorFindByCode)
+{
+    RadProto::Dictionaries a("dictionary");
+
+    BOOST_CHECK_EQUAL(a.vendorFindByName("Dlink"), true);
+    BOOST_CHECK_EQUAL(a.vendorFindByName("Name"), false);
+
+    BOOST_CHECK_EQUAL(a.vendorFindByCode(171), true);
+    BOOST_CHECK_EQUAL(a.vendorFindByCode(160), false);
+}
+
 BOOST_AUTO_TEST_CASE(TestVendorAttributeName)
 {
     RadProto::Dictionaries a("dictionary");