feat: Incorporated in internal code

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

Author: EmperorYP7

casbin/data_types.h

@@ -21,8 +21,10 @@
 #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();

casbin/enforcer_cached.cpp

@@ -150,13 +150,13 @@ bool CachedEnforcer ::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 CachedEnforcer::Enforce(const std::vector<std::string>& params) {
+bool CachedEnforcer::Enforce(const DataList& params) {
     return 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 CachedEnforcer::Enforce(const std::unordered_map<std::string, std::string>& params) {
+bool CachedEnforcer::Enforce(const DataMap& params) {
     return EnforceWithMatcher("", params);
 }
 
@@ -170,14 +170,28 @@ bool CachedEnforcer ::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 CachedEnforcer::EnforceWithMatcher(const std::string& matcher, const std::vector<std::string>& params) {
+bool CachedEnforcer::EnforceWithMatcher(const std::string& matcher, const DataList& params) {
     if (!enableCache) {
         return Enforcer::EnforceWithMatcher(matcher, params);
     }
 
     std::string key;
-    for (auto r : params) {
-        key += r;
+    for (const auto& r : params) {
+        if(const auto string_param = std::get_if<std::string>(&r))
+            key += *string_param;
+        else if(const auto abac_param = std::get_if<std::shared_ptr<ABACData>>(&r)) {
+            auto data_ptr = *abac_param;
+            for(auto [_, attrib_value] : data_ptr->GetAttributes()) {
+                if(auto string_value = std::get_if<std::string>(&attrib_value))
+                    key += *string_value + "$";
+                else if(auto int_value = std::get_if<int32_t>(&attrib_value))
+                    key += std::to_string(*int_value) + "$";
+                else if(auto double_value = std::get_if<double>(&attrib_value))
+                    key += std::to_string(*double_value) + "$";
+                else if(auto float_value = std::get_if<float>(&attrib_value))
+                    key += std::to_string(*float_value) + "$";
+            }
+        }
         key += "$$";
     }
     key += matcher;
@@ -197,14 +211,28 @@ bool CachedEnforcer::EnforceWithMatcher(const std::string& matcher, const std::v
 // 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 CachedEnforcer::EnforceWithMatcher(const std::string& matcher, const std::unordered_map<std::string, std::string>& params) {
+bool CachedEnforcer::EnforceWithMatcher(const std::string& matcher, const DataMap& params) {
     if (!enableCache) {
         return Enforcer::EnforceWithMatcher(matcher, params);
     }
 
     std::string key;
-    for (auto r : params) {
-        key += r.second;
+    for (auto [param_name, param_value] : params) {
+        if(const auto string_value = std::get_if<std::string>(&param_value))
+            key += *string_value;
+        else if(const auto abac_param = std::get_if<std::shared_ptr<ABACData>>(&param_value)) {
+            auto data_ptr = *abac_param;
+            for(auto [_, attrib_value] : data_ptr->GetAttributes()) {
+                if(auto string_value = std::get_if<std::string>(&attrib_value))
+                    key += *string_value + "$";
+                else if(auto int_value = std::get_if<int32_t>(&attrib_value))
+                    key += std::to_string(*int_value) + "$";
+                else if(auto double_value = std::get_if<double>(&attrib_value))
+                    key += std::to_string(*double_value) + "$";
+                else if(auto float_value = std::get_if<float>(&attrib_value))
+                    key += std::to_string(*float_value) + "$";
+            }
+        }
         key += "$$";
     }
     key += matcher;

casbin/enforcer_cached.h

@@ -88,10 +88,10 @@ class CachedEnforcer : public Enforcer {
     // 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
@@ -101,12 +101,12 @@ class CachedEnforcer : public Enforcer {
     // 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);
 };
 
 } // namespace casbin

casbin/enforcer_interface.h

@@ -60,8 +60,8 @@ class IEnforcer {
         virtual bool m_enforce(const std::string& matcher, Scope scope) = 0;
         virtual bool Enforce(Scope scope) = 0;
         virtual bool EnforceWithMatcher(const std::string& matcher, Scope scope) = 0;
-        virtual std::vector<bool> BatchEnforce(const std::vector<std::vector<std::string>>& requests) = 0;
-        virtual std::vector<bool> BatchEnforceWithMatcher(const std::string& matcher, const std::vector<std::vector<std::string>>& requests) = 0;
+        virtual std::vector<bool> BatchEnforce(const std::initializer_list<DataList>& requests) = 0;
+        virtual std::vector<bool> BatchEnforceWithMatcher(const std::string& matcher, const std::initializer_list<DataList>& requests) = 0;
 
         /* RBAC API */
         virtual std::vector<std::string> GetRolesForUser(const std::string& name, const std::vector<std::string>& domain = {}) = 0;

casbin/enforcer_synced.cpp

@@ -189,26 +189,26 @@ bool SyncedEnforcer ::Enforce(Scope s) {
 // 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 SyncedEnforcer ::Enforce(const std::vector<std::string>& params) {
+bool SyncedEnforcer ::Enforce(const DataList& params) {
     std::lock_guard<std::mutex> lock(policyMutex);
     return Enforcer::Enforce(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 SyncedEnforcer ::Enforce(const std::unordered_map<std::string, std::string>& params) {
+bool SyncedEnforcer ::Enforce(const DataMap& params) {
     std::lock_guard<std::mutex> lock(policyMutex);
     return Enforcer::Enforce(params);
 }
 
 // BatchEnforce enforce in batches
-std::vector<bool> SyncedEnforcer ::BatchEnforce(const std::vector<std::vector<std::string>>& requests) {
+std::vector<bool> SyncedEnforcer ::BatchEnforce(const std::initializer_list<DataList>& requests) {
   std::lock_guard<std::mutex> lock(policyMutex);
   return Enforcer::BatchEnforce(requests);
 }
 
 // BatchEnforceWithMatcher enforce with matcher in batches
-std::vector<bool> SyncedEnforcer ::BatchEnforceWithMatcher(const std::string& matcher, const std::vector<std::vector<std::string>>& requests) {
+std::vector<bool> SyncedEnforcer ::BatchEnforceWithMatcher(const std::string& matcher, const std::initializer_list<DataList>& requests) {
   std::lock_guard<std::mutex> lock(policyMutex);
   return Enforcer::BatchEnforceWithMatcher(matcher, requests);
 }

casbin/enforcer_synced.h

@@ -131,17 +131,17 @@ class SyncedEnforcer : public Enforcer {
     // 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);
 
     // 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);
 
     // GetAllSubjects gets the list of subjects that show up in the current policy.
     std::vector<std::string> GetAllSubjects();