feat: Streamlined types

Signed-off-by: Yash Pandey (YP) <[email protected]>

Author: EmperorYP7

casbin/abac_data.cpp

@@ -24,35 +24,22 @@
 
 namespace casbin {
 
-/**
- * @brief Get casbin::ABACData object
- * 
- * @param attribs Should be of the format: {
- * { "attrib_name1", value1 },
- * { "attrib_name2", value2 },
- * ...
- * }
- * 
- * Key's type is std::string and value's type can be one of std::string, int32_t, and float only
- * @return Pointer to casbin::ABACData entity
- */
-const std::shared_ptr<ABACData> GetData(const ABACData::VariantMap& attribs) {
+const std::shared_ptr<ABACData> GetDataObject(const AttributeMap& attribs) {
     return std::make_shared<ABACData>(attribs);
 }
 
-ABACData::ABACData(const VariantMap& attrib)
-        : m_attributes(attrib)
+ABACData::ABACData(const AttributeMap& attribs)
+        : m_attributes(std::move(attribs))
 {}
 
-bool ABACData::AddAttribute(const std::string& key, const VariantType& value) {
+bool ABACData::AddAttribute(const std::string& key, const AttributeValue& value) {
     m_attributes[key] = value;
     return true;
 }
 
-bool ABACData::AddAttributes(const VariantMap& attribs) {
-    for(auto attrib : attribs) {
-        m_attributes[attrib.first] = attrib.second;
-    }
+bool ABACData::AddAttributes(const AttributeList& attribs) {
+    for(auto [name, value] : attribs)
+        m_attributes[name] = value;
     return true;
 }
 
@@ -68,12 +55,12 @@ bool ABACData::DeleteAttribute(const std::string& key) {
     return true;
 }
 
-bool ABACData::UpdateAttribute(const std::string& key, const VariantType& value) {
+bool ABACData::UpdateAttribute(const std::string& key, const AttributeValue& value) {
     m_attributes[key] = value;
     return true;
 }
 
-const ABACData::VariantMap& ABACData::GetAttributes() {
+const AttributeMap& ABACData::GetAttributes() {
     return m_attributes;
 }
 

casbin/abac_data.h

@@ -17,11 +17,7 @@
 #ifndef ABAC_H
 #define ABAC_H
 
-#include <unordered_map>
-#include <string>
-#include <vector>
-#include <variant>
-#include <memory>
+#include "attribute_types.h"
 
 namespace casbin {
 
@@ -31,16 +27,10 @@ namespace casbin {
  */
 class ABACData {
 
-public:
-
-    // Intrinsic definitions
-    typedef std::variant<std::string, int32_t, float> VariantType;
-    typedef std::unordered_map<std::string, VariantType> VariantMap;
-
 private:
 
     // HashMap containing attributes as key-value pairs
-    VariantMap m_attributes;
+    AttributeMap m_attributes;
 
 public:
     /**
@@ -54,15 +44,15 @@ class ABACData {
      * 
      * Key's type is std::string and value's type can be one of std::string, int32_t, and float only
      */
-    ABACData(const VariantMap& attribs);
+    ABACData(const AttributeMap& attribs);
     /**
      * @brief Add attribute to the corresponding ABAC entity
      * 
      * @param key Name of the attribute
      * @param value Value of the attribute
      * @return true when attribute is added successfully, false otherwise
      */
-    bool AddAttribute(const std::string& key, const VariantType& value);
+    bool AddAttribute(const std::string& key, const AttributeValue& value);
     /**
      * @brief Add attributes to the corresponding ABAC entity
      * 
@@ -75,7 +65,7 @@ class ABACData {
      * Key's type is std::string and value's type can be one of std::string, int32_t, and float only
      * @return true if attributes are added successfully, false otherwise
      */
-    bool AddAttributes(const VariantMap& attribs);
+    bool AddAttributes(const AttributeList& attribs);
     /**
      * @brief Delete attribute of the corresponding ABAC entity
      * 
@@ -92,19 +82,31 @@ class ABACData {
      * @return true 
      * @return false 
      */
-    bool UpdateAttribute(const std::string& key, const VariantType& value);
+    bool UpdateAttribute(const std::string& key, const AttributeValue& value);
     /**
      * @brief Get the Attributes of the corresponding ABAC entity
      * 
      * @return const reference to the hashmap containing attributes in key-value pairs
      */
-    const VariantMap& GetAttributes();
+    const AttributeMap& GetAttributes();
 };
 
 // Casbin ABAC entity type
 typedef ABACData ABACData;
 
-const std::shared_ptr<ABACData> GetData(const ABACData::VariantMap& attribs);
+/**
+ * @brief Get casbin::ABACData object
+ * 
+ * @param attribs Should be of the format: {
+ * { "attrib_name1", value1 },
+ * { "attrib_name2", value2 },
+ * ...
+ * }
+ * 
+ * Key's type is std::string and value's type can be one of std::string, int32_t, double, and float only
+ * @return Pointer to casbin::ABACData entity
+ */
+const std::shared_ptr<ABACData> GetDataObject(const AttributeMap& attribs);
 }
 
 #endif

casbin/attribute_types.h

@@ -0,0 +1,31 @@
+/*
+* Copyright 2021 The casbin Authors. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <variant>
+#include <vector>
+#include <initializer_list>
+#include <unordered_map>
+#include <memory>
+
+namespace casbin {
+
+typedef std::variant<std::string, int32_t, float, double> AttributeValue;
+typedef std::pair<std::string, AttributeValue> Attribute;
+typedef std::vector<Attribute> AttributeVector;
+typedef std::initializer_list<Attribute> AttributeList;
+typedef std::unordered_map<std::string, AttributeValue> AttributeMap;
+
+} // namespace casbin

casbin/data_types.h

@@ -0,0 +1,28 @@
+/*
+* Copyright 2021 The casbin Authors. All Rights Reserved.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <variant>
+#include <vector>
+#include <initializer_list>
+#include <unordered_map>
+#include "abac_data.h"
+
+namespace casbin {
+typedef std::variant<std::string, std::shared_ptr<ABACData>> Data;
+typedef std::vector<Data> DataVector;
+typedef std::initializer_list<Data> DataList;
+typedef std::unordered_map<std::string, Data> DataMap;
+}

casbin/model/model.cpp

@@ -44,9 +44,9 @@ void Model::LoadModelFromConfig(std::shared_ptr<ConfigInterface> cfg) {
         LoadSection(this, cfg, it->first);
 
     std::vector<std::string> ms;
-    for(int i=0 ; i < required_sections.size() ; i++)
-        if(!this->HasSection(required_sections[i])) 
-            ms.push_back(section_name_map[required_sections[i]]);
+    for(const auto& required_section : required_sections)
+        if(!this->HasSection(required_section)) 
+            ms.push_back(section_name_map[required_section]);
 
     if(ms.size() > 0)
         throw MissingRequiredSections("missing required sections: " + Join(ms, ","));
@@ -70,11 +70,7 @@ void Model::LoadSection(Model* model, std::shared_ptr<ConfigInterface> cfg, cons
 std::string Model ::GetKeySuffix(int i) {
     if (i == 1)
         return "";
-    std::stringstream ss;
-    ss<<i;
-    std::string s;
-    ss>>s;
-    return s;
+    return std::to_string(i);
 }
 
 bool Model::LoadAssertion(Model* model, std::shared_ptr<ConfigInterface> cfg, const std::string& sec, const std::string& key) {
@@ -92,8 +88,8 @@ bool Model::AddDef(const std::string& sec, const std::string& key, const std::st
     ast->value = value;
     if (sec == "r" || sec == "p") {
         ast->tokens = Split(ast->value, ",");
-        for (int i = 0; i < ast->tokens.size() ; i++)
-            ast->tokens[i] = key + "_" + Trim(ast->tokens[i]);
+        for (auto& token : ast->tokens)
+            token = key + "_" + Trim(token);
     }
     else
         ast->value = RemoveComments(ast->value);

casbin/pch.h

@@ -38,5 +38,8 @@
 #include <future>
 #include <condition_variable>
 
+#include "attribute_types.h"
+#include "data_types.h"
+
 
 #endif //PCH_H

tests/enforcer_test.cpp

@@ -97,13 +97,13 @@ TEST(TestEnforcer, TestMapParams) {
 }
 
 TEST(TestEnforcer, ABACData) {
-    casbin::ABACData::VariantMap params = {
+    casbin::AttributeMap params = {
         { "Name", "Yash" },
         { "Grade", 8.6f },
         { "Age", 18 },
     };
 
-    auto data = casbin::GetData(params);
+    auto data = casbin::GetDataObject(params);
     ASSERT_TRUE(params == data->GetAttributes());
 
     data->DeleteAttribute("Name");