Merge pull request #62 from divy9881/constructor_interface

fix: Add constructor interface to Enforcer, Adapters, RoleManager and Effector.

Author: divy9881

casbin/config/config.cpp

@@ -97,8 +97,8 @@ void Config :: ParseBuffer(istream* buf){
  * @param confName the path of the model file.
  * @return the constructor of Config.
  */
-Config* Config :: NewConfig(string conf_name) {
-    Config* c = new Config;
+shared_ptr<Config> Config :: NewConfig(string conf_name) {
+    shared_ptr<Config> c(new Config);
     c->Parse(conf_name);
     return c;
 }
@@ -109,8 +109,8 @@ Config* Config :: NewConfig(string conf_name) {
  * @param text the model text.
  * @return the constructor of Config.
  */
-Config* Config :: NewConfigFromText(string text) {
-    Config *c = new Config;
+shared_ptr<Config> Config :: NewConfigFromText(string text) {
+    shared_ptr<Config> c(new Config);
     stringstream stream(text);
     c->ParseBuffer(&stream);
     return c;

casbin/config/config.h

@@ -17,6 +17,7 @@
 #ifndef CASBIN_CPP_CONFIG_CONFIG
 #define CASBIN_CPP_CONFIG_CONFIG
 
+#include <memory>
 #include <unordered_map>
 #include <mutex>
 
@@ -51,15 +52,15 @@ class Config : public ConfigInterface {
          * @param confName the path of the model file.
          * @return the constructor of Config.
          */
-        static Config* NewConfig(string conf_name);
+        static shared_ptr<Config> NewConfig(string conf_name);
 
         /**
          * newConfigFromText create an empty configuration representation from text.
          *
          * @param text the model text.
          * @return the constructor of Config.
          */
-        static Config* NewConfigFromText(string text);
+        static shared_ptr<Config> NewConfigFromText(string text);
 
         bool GetBool(string key);
 

casbin/effect/default_effector.cpp

@@ -21,12 +21,6 @@
 #include "./default_effector.h"
 #include "../exception/unsupported_operation_exception.h"
 
-// NewDefaultEffector is the constructor for DefaultEffector.
-DefaultEffector* DefaultEffector :: NewDefaultEffector(){
-    DefaultEffector* e = new DefaultEffector;
-    return e;
-}
-
 /**
  * MergeEffects merges all matching results collected by the enforcer into a single decision.
  */

casbin/effect/default_effector.h

@@ -25,9 +25,6 @@
 class DefaultEffector : public Effector{
     public:
 
-        // NewDefaultEffector is the constructor for DefaultEffector.
-        static DefaultEffector* NewDefaultEffector();
-
         /**
          * MergeEffects merges all matching results collected by the enforcer into a single decision.
          */

casbin/enforcer.cpp

@@ -54,17 +54,17 @@ bool Enforcer :: enforce(string matcher, Scope scope) {
         exp_string = matcher;
 
 
-    unordered_map <string, RoleManager*> rm_map;
+    unordered_map <string, shared_ptr<RoleManager>> rm_map;
     bool ok = this->model->m.find("g") != this->model->m.end();
 
     if(ok) {
-        for(unordered_map <string, Assertion*> :: iterator it = this->model->m["g"].assertion_map.begin() ; it != this->model->m["g"].assertion_map.end() ; it++){
-            RoleManager* rm = it->second->rm;
+        for(unordered_map <string, shared_ptr<Assertion>> :: iterator it = this->model->m["g"].assertion_map.begin() ; it != this->model->m["g"].assertion_map.end() ; it++){
+            shared_ptr<RoleManager> rm = it->second->rm;
             int char_count = int(count(it->second->value.begin(), it->second->value.end(), '_'));
             int index = int(exp_string.find((it->first)+"("));
             if(index != string::npos)
                 exp_string.insert(index+(it->first+"(").length(), "rm, ");
-            PushPointer(this->func_map.scope, (void *)rm, "rm");
+            PushPointer(this->func_map.scope, (void *)rm.get(), "rm");
             this->func_map.AddFunction(it->first, GFunction, char_count + 1);
         }
     }
@@ -162,9 +162,7 @@ bool Enforcer :: enforce(string matcher, Scope scope) {
 /**
  * Enforcer is the default constructor.
  */
-unique_ptr<Enforcer> Enforcer ::NewEnforcer() {
-    unique_ptr<Enforcer> e = unique_ptr<Enforcer>(new Enforcer());
-    return move(e);
+Enforcer ::Enforcer() {
 }
 
 /**
@@ -173,8 +171,7 @@ unique_ptr<Enforcer> Enforcer ::NewEnforcer() {
  * @param model_path the path of the model file.
  * @param policyFile the path of the policy file.
  */
-unique_ptr<Enforcer> Enforcer :: NewEnforcer(string model_path, string policyFile) {
-    return move(NewEnforcer(model_path, shared_ptr<FileAdapter>(FileAdapter :: NewAdapter(policyFile))));
+Enforcer :: Enforcer(string model_path, string policy_file): Enforcer(model_path, shared_ptr<FileAdapter>(new FileAdapter(policy_file))) {
 }
 
 /**
@@ -183,10 +180,8 @@ unique_ptr<Enforcer> Enforcer :: NewEnforcer(string model_path, string policyFil
  * @param model_path the path of the model file.
  * @param adapter the adapter.
  */
-unique_ptr<Enforcer> Enforcer :: NewEnforcer(string model_path, shared_ptr<Adapter> adapter) {
-    unique_ptr<Enforcer> e = NewEnforcer(shared_ptr<Model>(Model :: NewModelFromFile(model_path)), adapter);
-    e->model_path = model_path;
-    return move(e);
+Enforcer :: Enforcer(string model_path, shared_ptr<Adapter> adapter): Enforcer(shared_ptr<Model>(new Model(model_path)), adapter) {
+    this->model_path = model_path;
 }
 
 /**
@@ -195,39 +190,35 @@ unique_ptr<Enforcer> Enforcer :: NewEnforcer(string model_path, shared_ptr<Adapt
  * @param m the model.
  * @param adapter the adapter.
  */
-unique_ptr<Enforcer> Enforcer :: NewEnforcer(shared_ptr<Model> m, shared_ptr<Adapter> adapter) {
-  unique_ptr<Enforcer> e = unique_ptr<Enforcer>(new Enforcer());
-    e->adapter = adapter;
-    e->watcher = NULL;
+Enforcer :: Enforcer(shared_ptr<Model> m, shared_ptr<Adapter> adapter) {
+    this->adapter = adapter;
+    this->watcher = NULL;
 
-    e->model = m;
-    e->model->PrintModel();
-    e->func_map.LoadFunctionMap();
+    this->model = m;
+    this->model->PrintModel();
+    this->func_map.LoadFunctionMap();
 
-    e->Initialize();
+    this->Initialize();
 
-    if (e->adapter->file_path != "") {
-        e->LoadPolicy();
+    if (this->adapter->file_path != "") {
+        this->LoadPolicy();
     }
-    return move(e);
 }
 
 /**
  * Enforcer initializes an enforcer with a model.
  *
  * @param m the model.
  */
-unique_ptr<Enforcer> Enforcer ::NewEnforcer(shared_ptr<Model> m) {
-    return move(NewEnforcer(m, NULL));
+Enforcer ::Enforcer(shared_ptr<Model> m): Enforcer(m, NULL) {
 }
 
 /**
  * Enforcer initializes an enforcer with a model file.
  *
  * @param model_path the path of the model file.
  */
-unique_ptr<Enforcer> Enforcer ::NewEnforcer(string model_path) {
-    return move(NewEnforcer(model_path, ""));
+Enforcer ::Enforcer(string model_path): Enforcer(model_path, "") {
 }
 
 /**
@@ -237,16 +228,14 @@ unique_ptr<Enforcer> Enforcer ::NewEnforcer(string model_path) {
  * @param policyFile the path of the policy file.
  * @param enableLog whether to enable Casbin's log.
  */
-unique_ptr<Enforcer> Enforcer :: NewEnforcer(string model_path, string policyFile, bool enableLog) {
-    unique_ptr<Enforcer> e = NewEnforcer(model_path, shared_ptr<FileAdapter>(FileAdapter :: NewAdapter(policyFile)));
-    // e.EnableLog(enableLog);
-    return move(e);
+Enforcer :: Enforcer(string model_path, string policy_file, bool enable_log): Enforcer(model_path, shared_ptr<FileAdapter>(new FileAdapter(policy_file))) {
+    // e.EnableLog(enable_log);
 }
 
 
 // InitWithFile initializes an enforcer with a model file and a policy file.
-void Enforcer :: InitWithFile(string model_path, string policyPath) {
-    shared_ptr<Adapter> a = shared_ptr<FileAdapter>(FileAdapter::NewAdapter(policyPath));
+void Enforcer :: InitWithFile(string model_path, string policy_path) {
+    shared_ptr<Adapter> a = shared_ptr<FileAdapter>(new FileAdapter(policy_path));
     this->InitWithAdapter(model_path, a);
 }
 
@@ -275,8 +264,8 @@ void Enforcer :: InitWithModelAndAdapter(shared_ptr<Model> m, shared_ptr<Adapter
 }
 
 void Enforcer :: Initialize() {
-    this->rm = shared_ptr<DefaultRoleManager>(DefaultRoleManager :: NewRoleManager(10));
-    this->eft = shared_ptr<DefaultEffector>(DefaultEffector :: NewDefaultEffector());
+    this->rm = shared_ptr<DefaultRoleManager>(new DefaultRoleManager(10));
+    this->eft = shared_ptr<DefaultEffector>(new DefaultEffector());
     this->watcher = NULL;
 
     this->enabled = true;
@@ -350,7 +339,7 @@ void Enforcer :: ClearPolicy() {
 
 // LoadPolicy reloads the policy from file/database.
 void Enforcer :: LoadPolicy() {
-    this->model->ClearPolicy();
+    this->ClearPolicy();
     this->adapter->LoadPolicy(this->model.get());
     this->model->PrintPolicy();
 
@@ -362,18 +351,17 @@ void Enforcer :: LoadPolicy() {
 //LoadFilteredPolicy reloads a filtered policy from file/database.
 template<typename Filter>
 void Enforcer :: LoadFilteredPolicy(Filter filter) {
-    this->model->ClearPolicy();
+    this->ClearPolicy();
 
-    FilteredAdapter* filteredAdapter;
+    shared_ptr<FilteredAdapter> filtered_adapter;
 
     if (this->adapter->IsFiltered()) {
-        void* adapter = this->adapter.get();
-        filteredAdapter = (FilteredAdapter*)adapter;
+        filtered_adapter = dynamic_pointer_cast<FilteredAdapter>(this->adapter);
     }
     else
         throw CasbinAdapterException("filtered policies are not supported by this adapter");
 
-    filteredAdapter->LoadFilteredPolicy(this->model, filter);
+    filtered_adapter->LoadFilteredPolicy(this->model, filter);
 
     this->model->PrintPolicy();
     if(this->auto_build_role_links)
@@ -431,12 +419,12 @@ void Enforcer :: EnableAutoBuildRoleLinks(bool auto_build_role_links) {
 void Enforcer :: BuildRoleLinks() {
     this->rm->Clear();
 
-    this->model->BuildRoleLinks(this->rm.get());
+    this->model->BuildRoleLinks(this->rm);
 }
 
 // BuildIncrementalRoleLinks provides incremental build the role inheritance relations.
 void Enforcer :: BuildIncrementalRoleLinks(policy_op op, string p_type, vector<vector<string>> rules) {
-    return this->model->BuildIncrementalRoleLinks(this->rm.get(), op, "g", p_type, rules);
+    return this->model->BuildIncrementalRoleLinks(this->rm, op, "g", p_type, rules);
 }
 
 // Enforce decides whether a "subject" can access a "object" with the operation "action", input parameters are usually: (sub, obj, act).

casbin/enforcer.h

@@ -50,50 +50,50 @@ class Enforcer : public IEnforcer{
         /**
          * Enforcer is the default constructor.
          */
-        static unique_ptr<Enforcer> NewEnforcer();
+        Enforcer();
         /**
          * Enforcer initializes an enforcer with a model file and a policy file.
          *
          * @param model_path the path of the model file.
-         * @param policyFile the path of the policy file.
+         * @param policy_file the path of the policy file.
          */
-        static unique_ptr<Enforcer> NewEnforcer(string model_path, string policyFile);
+        Enforcer(string model_path, string policy_file);
         /**
          * Enforcer initializes an enforcer with a database adapter.
          *
          * @param model_path the path of the model file.
          * @param adapter the adapter.
          */
-        static unique_ptr<Enforcer> NewEnforcer(string model_path, shared_ptr<Adapter> adapter);
+        Enforcer(string model_path, shared_ptr<Adapter> adapter);
         /**
          * Enforcer initializes an enforcer with a model and a database adapter.
          *
          * @param m the model.
          * @param adapter the adapter.
          */
-        static unique_ptr<Enforcer> NewEnforcer(shared_ptr<Model> m, shared_ptr<Adapter> adapter);
+        Enforcer(shared_ptr<Model> m, shared_ptr<Adapter> adapter);
         /**
          * Enforcer initializes an enforcer with a model.
          *
          * @param m the model.
          */
-        static unique_ptr<Enforcer> NewEnforcer(shared_ptr<Model> m);
+        Enforcer(shared_ptr<Model> m);
         /**
          * Enforcer initializes an enforcer with a model file.
          *
          * @param model_path the path of the model file.
          */
-        static unique_ptr<Enforcer> NewEnforcer(string model_path);
+        Enforcer(string model_path);
         /**
          * Enforcer initializes an enforcer with a model file, a policy file and an enable log flag.
          *
          * @param model_path the path of the model file.
-         * @param policyFile the path of the policy file.
-         * @param enableLog whether to enable Casbin's log.
+         * @param policy_file the path of the policy file.
+         * @param enable_log whether to enable Casbin's log.
          */
-        static unique_ptr<Enforcer> NewEnforcer(string model_path, string policyFile, bool enableLog);
+        Enforcer(string model_path, string policy_file, bool enable_log);
         // InitWithFile initializes an enforcer with a model file and a policy file.
-        void InitWithFile(string model_path, string policyPath);
+        void InitWithFile(string model_path, string policy_path);
         // InitWithAdapter initializes an enforcer with a database adapter.
         void InitWithAdapter(string model_path, shared_ptr<Adapter> adapter);
         // InitWithModelAndAdapter initializes an enforcer with a model and a database adapter.
@@ -161,45 +161,45 @@ class Enforcer : public IEnforcer{
 
         /*Management API member functions.*/
         vector<string> GetAllSubjects();
-        vector<string> GetAllNamedSubjects(string ptype);
+        vector<string> GetAllNamedSubjects(string p_type);
         vector<string> GetAllObjects();
-        vector<string> GetAllNamedObjects(string ptype);
+        vector<string> GetAllNamedObjects(string p_type);
         vector<string> GetAllActions();
-        vector<string> GetAllNamedActions(string ptype);
+        vector<string> GetAllNamedActions(string p_type);
         vector<string> GetAllRoles();
-        vector<string> GetAllNamedRoles(string ptype);
+        vector<string> GetAllNamedRoles(string p_type);
         vector<vector<string>> GetPolicy();
         vector<vector<string>> GetFilteredPolicy(int field_index, vector<string> field_values);
-        vector<vector<string>> GetNamedPolicy(string ptype);
-        vector<vector<string>> GetFilteredNamedPolicy(string ptype, int field_index, vector<string> field_values);
+        vector<vector<string>> GetNamedPolicy(string p_type);
+        vector<vector<string>> GetFilteredNamedPolicy(string p_type, int field_index, vector<string> field_values);
         vector<vector<string>> GetGroupingPolicy();
         vector<vector<string>> GetFilteredGroupingPolicy(int field_index, vector<string> field_values);
-        vector<vector<string>> GetNamedGroupingPolicy(string ptype);
-        vector<vector<string>> GetFilteredNamedGroupingPolicy(string ptype, int field_index, vector<string> field_values);
+        vector<vector<string>> GetNamedGroupingPolicy(string p_type);
+        vector<vector<string>> GetFilteredNamedGroupingPolicy(string p_type, int field_index, vector<string> field_values);
         bool HasPolicy(vector<string> params);
-        bool HasNamedPolicy(string ptype, vector<string> params);
+        bool HasNamedPolicy(string p_type, vector<string> params);
         bool AddPolicy(vector<string> params);
         bool  AddPolicies(vector<vector<string>> rules);
-        bool AddNamedPolicy(string ptype, vector<string> params);
+        bool AddNamedPolicy(string p_type, vector<string> params);
         bool AddNamedPolicies(string p_type, vector<vector<string>> rules);
         bool RemovePolicy(vector<string> params);
         bool RemovePolicies(vector<vector<string>> rules);
         bool RemoveFilteredPolicy(int field_index, vector<string> field_values);
-        bool RemoveNamedPolicy(string ptype, vector<string> params);
+        bool RemoveNamedPolicy(string p_type, vector<string> params);
         bool RemoveNamedPolicies(string p_type, vector<vector<string>> rules);
-        bool RemoveFilteredNamedPolicy(string ptype, int field_index, vector<string> field_values);
+        bool RemoveFilteredNamedPolicy(string p_type, int field_index, vector<string> field_values);
         bool HasGroupingPolicy(vector<string> params);
-        bool HasNamedGroupingPolicy(string ptype, vector<string> params);
+        bool HasNamedGroupingPolicy(string p_type, vector<string> params);
         bool AddGroupingPolicy(vector<string> params);
         bool AddGroupingPolicies(vector<vector<string>> rules);
-        bool AddNamedGroupingPolicy(string ptype, vector<string> params);
+        bool AddNamedGroupingPolicy(string p_type, vector<string> params);
         bool AddNamedGroupingPolicies(string p_type, vector<vector<string>> rules);
         bool RemoveGroupingPolicy(vector<string> params);
         bool RemoveGroupingPolicies(vector<vector<string>> rules);
         bool RemoveFilteredGroupingPolicy(int field_index, vector<string> field_values);
-        bool RemoveNamedGroupingPolicy(string ptype, vector<string> params);
+        bool RemoveNamedGroupingPolicy(string p_type, vector<string> params);
         bool RemoveNamedGroupingPolicies(string p_type, vector<vector<string>> rules);
-        bool RemoveFilteredNamedGroupingPolicy(string ptype, int field_index, vector<string> field_values);
+        bool RemoveFilteredNamedGroupingPolicy(string p_type, int field_index, vector<string> field_values);
         void AddFunction(string name, Function function, Index nargs);
 
         /*RBAC API member functions.*/
@@ -223,11 +223,11 @@ class Enforcer : public IEnforcer{
         bool DeletePermission(vector<string> permission);
 
         /* Internal API member functions */
-        bool addPolicy(string sec, string ptype, vector<string> rule);
+        bool addPolicy(string sec, string p_type, vector<string> rule);
         bool addPolicies(string sec, string p_type, vector<vector<string>> rules);
-        bool removePolicy(string sec , string ptype , vector<string> rule);
+        bool removePolicy(string sec , string p_type , vector<string> rule);
         bool removePolicies(string sec, string p_type, vector<vector<string>> rules);
-        bool removeFilteredPolicy(string sec , string ptype , int fieldIndex , vector<string> fieldValues);
+        bool removeFilteredPolicy(string sec , string p_type , int field_index , vector<string> field_values);
 
         /* RBAC API with domains.*/
         vector<string> GetUsersForRoleInDomain(string name, string domain = {});