Merge pull request #122 from EmperorYP7/abac

feat: Streamlined types

Author: hsluoyz

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,30 @@
+/*
+* 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;
+
+} // namespace casbin

casbin/enforcer.cpp

@@ -435,12 +435,12 @@ bool Enforcer :: Enforce(Scope scope) {
 }
 
 // Enforce with a vector param,decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).
-bool Enforcer::Enforce(const std::vector<std::string>& params) {
+bool Enforcer::Enforce(const DataList& params) {
     return this->EnforceWithMatcher("", params);
 }
 
 // Enforce with a map param,decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).
-bool Enforcer::Enforce(const std::unordered_map<std::string, std::string>& params) {
+bool Enforcer::Enforce(const DataMap& params) {
     return this->EnforceWithMatcher("", params);
 }
 
@@ -450,22 +450,55 @@ bool Enforcer :: EnforceWithMatcher(const std::string& matcher, Scope scope) {
 }
 
 // EnforceWithMatcher use a custom matcher to decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (matcher, sub, obj, act), use model matcher by default when matcher is "".
-bool Enforcer::EnforceWithMatcher(const std::string& matcher, const std::vector<std::string>& params) {
-    std::vector<std::string> r_tokens = m_model->m["r"].assertion_map["r"]->tokens;
+bool Enforcer::EnforceWithMatcher(const std::string& matcher, const DataList& params) {
+    const std::vector<std::string>& r_tokens = m_model->m["r"].assertion_map["r"]->tokens;
 
-    int r_cnt = int(r_tokens.size());
-    int cnt = int(params.size());
+    size_t r_cnt = r_tokens.size();
+    size_t cnt = params.size();
 
     if (cnt != r_cnt)
         return false;
 
     Scope scope = InitializeScope();
     PushObject(scope, "r");
 
-    for (int i = 0; i < cnt; i++) {
-        PushStringPropToObject(scope, "r", params[i], r_tokens[i].substr(2, r_tokens[i].size() - 2));
+    size_t i = 0;
+
+    for(const auto& param : params) {
+        if(const auto string_param = std::get_if<std::string>(&param)) {
+            PushStringPropToObject(scope, "r", *string_param, r_tokens[i].substr(2, r_tokens[i].size() - 2));
+        }
+        else if(const auto abac_param = std::get_if<std::shared_ptr<ABACData>>(&param)) {
+            auto data_ptr = *abac_param;
+            std::string token_name = r_tokens[i].substr(2, r_tokens[i].size() - 2);
+
+            PushObjectPropToObject(scope, "r", token_name);
+
+            for(auto [attrib_name, attrib_value] : data_ptr->GetAttributes()) {
+
+                if(const auto string_value = std::get_if<std::string>(&attrib_value))
+                    PushStringPropToObject(scope, token_name, *string_value, attrib_name);
+
+                else if(const auto int_value = std::get_if<int32_t>(&attrib_value))
+                    PushIntPropToObject(scope, token_name, *int_value, attrib_name);
+                
+                else if(const auto float_value = std::get_if<float>(&attrib_value))
+                    PushFloatPropToObject(scope, token_name, *float_value, attrib_name);
+                
+                else if(const auto double_value = std::get_if<double>(&attrib_value))
+                    PushDoublePropToObject(scope, token_name, *double_value, attrib_name);
+                
+                else
+                    throw CasbinEnforcerException("Not a valid type");
+            }
+        }
+        ++i;
     }
 
+    // for (size_t i = 0; i < cnt; i++) {
+    //     PushStringPropToObject(scope, "r", params[i], r_tokens[i].substr(2, r_tokens[i].size() - 2));
+    // }
+
     bool result = m_enforce(matcher, scope);
     DeinitializeScope(scope);
     return result;
@@ -474,12 +507,36 @@ bool Enforcer::EnforceWithMatcher(const std::string& matcher, const std::vector<
 // EnforceWithMatcher use a custom matcher to decides whether a "subject" can access a "object" 
 // with the operation "action", input parameters are usually: (matcher, sub, obj, act), 
 // use model matcher by default when matcher is "".
-bool Enforcer::EnforceWithMatcher(const std::string& matcher, const std::unordered_map<std::string, std::string>& params) {
+bool Enforcer::EnforceWithMatcher(const std::string& matcher, const DataMap& params) {
     Scope scope = InitializeScope();
     PushObject(scope, "r");
 
-    for (auto r : params) {
-        PushStringPropToObject(scope, "r", r.second, r.first);
+    for (auto [param_name, param_data] : params) {
+        if(const auto string_param = std::get_if<std::string>(&param_data))
+            PushStringPropToObject(scope, "r", *string_param, param_name);
+        else if(const auto abac_param = std::get_if<std::shared_ptr<ABACData>>(&param_data)) {
+            auto data_ptr = *abac_param;
+
+            PushObjectPropToObject(scope, "r", param_name);
+
+            for(auto [attrib_name, attrib_value] : data_ptr->GetAttributes()) {
+
+                if(const auto string_value = std::get_if<std::string>(&attrib_value))
+                    PushStringPropToObject(scope, param_name, *string_value, attrib_name);
+
+                else if(const auto int_value = std::get_if<int32_t>(&attrib_value))
+                    PushIntPropToObject(scope, param_name, *int_value, attrib_name);
+                
+                else if(const auto float_value = std::get_if<float>(&attrib_value))
+                    PushFloatPropToObject(scope, param_name, *float_value, attrib_name);
+                
+                else if(const auto double_value = std::get_if<double>(&attrib_value))
+                    PushDoublePropToObject(scope, param_name, *double_value, attrib_name);
+                
+                else
+                    throw CasbinEnforcerException("Not a valid type");
+            }
+        }
     }
 
     bool result = m_enforce(matcher, scope);
@@ -488,21 +545,21 @@ bool Enforcer::EnforceWithMatcher(const std::string& matcher, const std::unorder
 }
 
 // BatchEnforce enforce in batches
-std::vector<bool> Enforcer :: BatchEnforce(const std::vector<std::vector<std::string>>& requests) {
+std::vector<bool> Enforcer :: BatchEnforce(const std::initializer_list<DataList>& requests) {
     // Initializing an array for storing results with false
     std::vector<bool> results;
     results.reserve(requests.size());
-    for (auto request : requests) {
+    for (const auto& request : requests) {
         results.push_back(this->Enforce(request));
     }
     return results;
 }
 
 // BatchEnforceWithMatcher enforce with matcher in batches
-std::vector<bool> Enforcer :: BatchEnforceWithMatcher(const std::string& matcher, const std::vector<std::vector<std::string>>& requests) {
+std::vector<bool> Enforcer :: BatchEnforceWithMatcher(const std::string& matcher, const std::initializer_list<DataList>& requests) {
     std::vector<bool> results;
     results.reserve(requests.size());
-    for (auto request : requests) {
+    for (const auto& request : requests) {
         results.push_back(this->EnforceWithMatcher(matcher, request));
     }
     return results;

casbin/enforcer.h

@@ -156,19 +156,19 @@ class Enforcer : public IEnforcer {
         // Enforce decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).
         bool Enforce(Scope scope);
         // Enforce with a vector param,decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).
-        bool Enforce(const std::vector<std::string>& params);
+        bool Enforce(const DataList& params);
         // Enforce with a map param,decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).
-        bool Enforce(const std::unordered_map<std::string,std::string>& params);
+        bool Enforce(const DataMap& params);
         // EnforceWithMatcher use a custom matcher to decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (matcher, sub, obj, act), use model matcher by default when matcher is "".
         bool EnforceWithMatcher(const std::string& matcher, Scope scope);
         // EnforceWithMatcher use a custom matcher to decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (matcher, sub, obj, act), use model matcher by default when matcher is "".
-        bool EnforceWithMatcher(const std::string& matcher, const std::vector<std::string>& params);
+        bool EnforceWithMatcher(const std::string& matcher, const DataList& params);
         // EnforceWithMatcher use a custom matcher to decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (matcher, sub, obj, act), use model matcher by default when matcher is "".
-        bool EnforceWithMatcher(const std::string& matcher, const std::unordered_map<std::string, std::string>& params);
+        bool EnforceWithMatcher(const std::string& matcher, const DataMap& params);
         // BatchEnforce enforce in batches
-        std::vector<bool> BatchEnforce(const std::vector<std::vector<std::string>>& requests);
+        std::vector<bool> BatchEnforce(const std::initializer_list<DataList>& requests);
         // BatchEnforceWithMatcher enforce with matcher in batches
-        std::vector<bool> BatchEnforceWithMatcher(const std::string& matcher, const std::vector<std::vector<std::string>>& requests);
+        std::vector<bool> BatchEnforceWithMatcher(const std::string& matcher, const std::initializer_list<DataList>& requests);
 
         /*Management API member functions.*/
         std::vector<std::string> GetAllSubjects();