casbin/management_api.cpp - casbin-cpp - Git at Google

 /*
  * Copyright 2020 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 "casbin/pch.h"

 #ifndef MANAGEMENT_API_CPP
 #define MANAGEMENT_API_CPP

 #include "casbin/enforcer.h"

 namespace casbin {

 // GetAllSubjects gets the list of subjects that show up in the current policy.
 std::vector<std::string> Enforcer ::GetAllSubjects() {
     return m_model->GetValuesForFieldInPolicyAllTypes("p", 0);
 }

 // GetAllNamedSubjects gets the list of subjects that show up in the current named policy.
 std::vector<std::string> Enforcer ::GetAllNamedSubjects(const std::string& p_type) {
     return m_model->GetValuesForFieldInPolicy("p", p_type, 0);
 }

 // GetAllObjects gets the list of objects that show up in the current policy.
 std::vector<std::string> Enforcer ::GetAllObjects() {
     return m_model->GetValuesForFieldInPolicyAllTypes("p", 1);
 }

 // GetAllNamedObjects gets the list of objects that show up in the current named policy.
 std::vector<std::string> Enforcer ::GetAllNamedObjects(const std::string& p_type) {
     return m_model->GetValuesForFieldInPolicy("p", p_type, 1);
 }

 // GetAllActions gets the list of actions that show up in the current policy.
 std::vector<std::string> Enforcer ::GetAllActions() {
     return m_model->GetValuesForFieldInPolicyAllTypes("p", 2);
 }

 // GetAllNamedActions gets the list of actions that show up in the current named policy.
 std::vector<std::string> Enforcer ::GetAllNamedActions(const std::string& p_type) {
     return m_model->GetValuesForFieldInPolicy("p", p_type, 2);
 }

 // GetAllRoles gets the list of roles that show up in the current policy.
 std::vector<std::string> Enforcer ::GetAllRoles() {
     return m_model->GetValuesForFieldInPolicyAllTypes("g", 1);
 }

 // GetAllNamedRoles gets the list of roles that show up in the current named policy.
 std::vector<std::string> Enforcer ::GetAllNamedRoles(const std::string& p_type) {
     return m_model->GetValuesForFieldInPolicy("g", p_type, 1);
 }

 // GetPolicy gets all the authorization rules in the policy.
 PoliciesValues Enforcer ::GetPolicy() {
     return this->GetNamedPolicy("p");
 }

 // GetFilteredPolicy gets all the authorization rules in the policy, field filters can be specified.
 PoliciesValues Enforcer ::GetFilteredPolicy(int field_index, const std::vector<std::string>& field_values) {
     return this->GetFilteredNamedPolicy("p", field_index, field_values);
 }

 // GetNamedPolicy gets all the authorization rules in the named policy.
 PoliciesValues Enforcer ::GetNamedPolicy(const std::string& p_type) {
     return m_model->GetPolicy("p", p_type);
 }

 // GetFilteredNamedPolicy gets all the authorization rules in the named policy, field filters can be specified.
 PoliciesValues Enforcer ::GetFilteredNamedPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
     return m_model->GetFilteredPolicy("p", p_type, field_index, field_values);
 }

 // GetGroupingPolicy gets all the role inheritance rules in the policy.
 PoliciesValues Enforcer ::GetGroupingPolicy() {
     return this->GetNamedGroupingPolicy("g");
 }

 // GetFilteredGroupingPolicy gets all the role inheritance rules in the policy, field filters can be specified.
 PoliciesValues Enforcer ::GetFilteredGroupingPolicy(int field_index, const std::vector<std::string>& field_values) {
     return this->GetFilteredNamedGroupingPolicy("g", field_index, field_values);
 }

 // GetNamedGroupingPolicy gets all the role inheritance rules in the policy.
 PoliciesValues Enforcer ::GetNamedGroupingPolicy(const std::string& p_type) {
     return m_model->GetPolicy("g", p_type);
 }

 // GetFilteredNamedGroupingPolicy gets all the role inheritance rules in the policy, field filters can be specified.
 PoliciesValues Enforcer ::GetFilteredNamedGroupingPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
     return m_model->GetFilteredPolicy("g", p_type, field_index, field_values);
 }

 // HasPolicy determines whether an authorization rule exists.
 bool Enforcer ::HasPolicy(const std::vector<std::string>& params) {
     return this->HasNamedPolicy("p", params);
 }

 // HasNamedPolicy determines whether a named authorization rule exists.
 bool Enforcer ::HasNamedPolicy(const std::string& p_type, const std::vector<std::string>& params) {
     if (params.size() == 1) {
         std::vector<std::string> str_slice{params[0]};
         return m_model->HasPolicy("p", p_type, str_slice);
     }

     std::vector<std::string> policy;
     for (int i = 0; i < params.size(); i++)
         policy.push_back(params[i]);
     return m_model->HasPolicy("p", p_type, policy);
 }

 // AddPolicy adds an authorization rule to the current policy.
 // If the rule already exists, the function returns false and the rule will not be added.
 // Otherwise the function returns true by adding the new rule.
 bool Enforcer ::AddPolicy(const std::vector<std::string>& params) {
     return this->AddNamedPolicy("p", params);
 }

 // AddPolicies adds authorization rules to the current policy.
 // If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
 // Otherwise the function returns true for the corresponding rule by adding the new rule.
 bool Enforcer ::AddPolicies(const PoliciesValues& rules) {
     return this->AddNamedPolicies("p", rules);
 }

 // AddNamedPolicy adds an authorization rule to the current named policy.
 // If the rule already exists, the function returns false and the rule will not be added.
 // Otherwise the function returns true by adding the new rule.
 bool Enforcer ::AddNamedPolicy(const std::string& p_type, const std::vector<std::string>& params) {
     if (params.size() == 1) {
         std::vector<std::string> str_slice{params[0]};
         return this->addPolicy("p", p_type, str_slice);
     }

     return this->addPolicy("p", p_type, params);
 }

 // AddNamedPolicies adds authorization rules to the current named policy.
 // If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
 // Otherwise the function returns true for the corresponding by adding the new rule.
 bool Enforcer ::AddNamedPolicies(const std::string& p_type, const PoliciesValues& rules) {
     return this->addPolicies("p", p_type, rules);
 }

 // RemovePolicy removes an authorization rule from the current policy.
 bool Enforcer ::RemovePolicy(const std::vector<std::string>& params) {
     return this->RemoveNamedPolicy("p", params);
 }

 // RemovePolicies removes authorization rules from the current policy.
 bool Enforcer ::RemovePolicies(const PoliciesValues& rules) {
     return this->RemoveNamedPolicies("p", rules);
 }

 // RemoveFilteredPolicy removes an authorization rule from the current policy, field filters can be specified.
 bool Enforcer ::RemoveFilteredPolicy(int field_index, const std::vector<std::string>& field_values) {
     return this->RemoveFilteredNamedPolicy("p", field_index, field_values);
 }

 // RemoveNamedPolicy removes an authorization rule from the current named policy.
 bool Enforcer ::RemoveNamedPolicy(const std::string& p_type, const std::vector<std::string>& params) {
     if (params.size() == 1) {
         std::vector<std::string> str_slice{params[0]};
         return this->removePolicy("p", p_type, str_slice);
     }

     std::vector<std::string> policy;
     for (int i = 0; i < params.size(); i++)
         policy.push_back(params[i]);
     return this->removePolicy("p", p_type, policy);
 }

 // RemoveNamedPolicies removes authorization rules from the current named policy.
 bool Enforcer ::RemoveNamedPolicies(const std::string& p_type, const PoliciesValues& rules) {
     return this->removePolicies("p", p_type, rules);
 }

 // RemoveFilteredNamedPolicy removes an authorization rule from the current named policy, field filters can be specified.
 bool Enforcer ::RemoveFilteredNamedPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
     return this->removeFilteredPolicy("p", p_type, field_index, field_values);
 }

 // HasGroupingPolicy determines whether a role inheritance rule exists.
 bool Enforcer ::HasGroupingPolicy(const std::vector<std::string>& params) {
     return this->HasNamedGroupingPolicy("g", params);
 }

 // HasNamedGroupingPolicy determines whether a named role inheritance rule exists.
 bool Enforcer ::HasNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& params) {
     if (params.size() == 1) {
         std::vector<std::string> str_slice{params[0]};
         return m_model->HasPolicy("g", p_type, str_slice);
     }

     std::vector<std::string> policy;
     for (int i = 0; i < params.size(); i++)
         policy.push_back(params[i]);
     return m_model->HasPolicy("g", p_type, policy);
 }

 // AddGroupingPolicy adds a role inheritance rule to the current policy.
 // If the rule already exists, the function returns false and the rule will not be added.
 // Otherwise the function returns true by adding the new rule.
 bool Enforcer ::AddGroupingPolicy(const std::vector<std::string>& params) {
     return this->AddNamedGroupingPolicy("g", params);
 }

 // AddGroupingPolicies adds role inheritance rulea to the current policy.
 // If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
 // Otherwise the function returns true for the corresponding policy rule by adding the new rule.
 bool Enforcer ::AddGroupingPolicies(const PoliciesValues& rules) {
     return this->AddNamedGroupingPolicies("g", rules);
 }

 // AddNamedGroupingPolicy adds a named role inheritance rule to the current policy.
 // If the rule already exists, the function returns false and the rule will not be added.
 // Otherwise the function returns true by adding the new rule.
 bool Enforcer ::AddNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& params) {
     bool rule_added;
     if (params.size() == 1) {
         std::vector<std::string> str_slice{params[0]};
         rule_added = this->addPolicy("g", p_type, str_slice);
     } else {
         std::vector<std::string> policy;
         for (int i = 0; i < params.size(); i++)
             policy.push_back(params[i]);

         rule_added = this->addPolicy("g", p_type, policy);
     }

     if (m_auto_build_role_links)
         this->BuildIncrementalRoleLinks(policy_add, p_type, PoliciesValues({params}));
     // this->BuildRoleLinks();

     return rule_added;
 }

 // AddNamedGroupingPolicies adds named role inheritance rules to the current policy.
 // If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
 // Otherwise the function returns true for the corresponding policy rule by adding the new rule.
 bool Enforcer ::AddNamedGroupingPolicies(const std::string& p_type, const PoliciesValues& rules) {
     return this->addPolicies("g", p_type, rules);
 }

 // RemoveGroupingPolicy removes a role inheritance rule from the current policy.
 bool Enforcer ::RemoveGroupingPolicy(const std::vector<std::string>& params) {
     return this->RemoveNamedGroupingPolicy("g", params);
 }

 // RemoveGroupingPolicies removes role inheritance rulea from the current policy.
 bool Enforcer ::RemoveGroupingPolicies(const PoliciesValues& rules) {
     return this->RemoveNamedGroupingPolicies("g", rules);
 }

 // RemoveFilteredGroupingPolicy removes a role inheritance rule from the current policy, field filters can be specified.
 bool Enforcer ::RemoveFilteredGroupingPolicy(int field_index, const std::vector<std::string>& field_values) {
     return this->RemoveFilteredNamedGroupingPolicy("g", field_index, field_values);
 }

 // RemoveNamedGroupingPolicy removes a role inheritance rule from the current named policy.
 bool Enforcer ::RemoveNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& params) {
     bool rule_removed;
     if (params.size() == 1) {
         std::vector<std::string> str_slice{params[0]};
         rule_removed = this->removePolicy("g", p_type, str_slice);
     } else {
         std::vector<std::string> policy;
         for (int i = 0; i < params.size(); i++)
             policy.push_back(params[i]);

         rule_removed = this->removePolicy("g", p_type, policy);
     }

     if (m_auto_build_role_links)
         this->BuildRoleLinks();

     return rule_removed;
 }

 // RemoveNamedGroupingPolicies removes role inheritance rules from the current named policy.
 bool Enforcer ::RemoveNamedGroupingPolicies(const std::string& p_type, const PoliciesValues& rules) {
     return this->removePolicies("g", p_type, rules);
 }

 // RemoveFilteredNamedGroupingPolicy removes a role inheritance rule from the current named policy, field filters can be specified.
 bool Enforcer ::RemoveFilteredNamedGroupingPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
     bool rule_removed = this->removeFilteredPolicy("g", p_type, field_index, field_values);

     if (m_auto_build_role_links)
         this->BuildRoleLinks();

     return rule_removed;
 }

 bool Enforcer ::UpdateGroupingPolicy(const std::vector<std::string>& oldRule, const std::vector<std::string>& newRule) {
     return UpdateNamedGroupingPolicy("g", oldRule, newRule);
 }

 bool Enforcer ::UpdateNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& oldRule, const std::vector<std::string>& newRule) {
     return this->updatePolicy("g", p_type, oldRule, newRule);
 }

 // UpdatePolicy updates an authorization rule from the current policy.
 bool Enforcer ::UpdatePolicy(const std::vector<std::string>& oldPolicy, const std::vector<std::string>& newPolicy) {
     return UpdateNamedPolicy("p", oldPolicy, newPolicy);
 }

 bool Enforcer ::UpdateNamedPolicy(const std::string& ptype, const std::vector<std::string>& p1, const std::vector<std::string>& p2) {
     return this->updatePolicy("p", ptype, p1, p2);
 }

 // UpdatePolicies updates authorization rules from the current policies.
 bool Enforcer ::UpdatePolicies(const PoliciesValues& oldPolices, const PoliciesValues& newPolicies) {
     return UpdateNamedPolicies("p", oldPolices, newPolicies);
 }

 bool Enforcer ::UpdateNamedPolicies(const std::string& ptype, const PoliciesValues& p1, const PoliciesValues& p2) {
     return this->updatePolicies("p", ptype, p1, p2);
 }

 // AddNamedMatchingFunc add MatchingFunc by ptype RoleManager
 bool Enforcer ::AddNamedMatchingFunc(const std::string& ptype, const std::string& name, casbin::MatchingFunc func) {
     auto default_rm = dynamic_cast<casbin::DefaultRoleManager*>(this->rm.get());
     default_rm->AddMatchingFunc(func);

     return true;
 }

 } // namespace casbin

 #endif // MANAGEMENT_API_CPP
	/*
	* Copyright 2020 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 "casbin/pch.h"

	#ifndef MANAGEMENT_API_CPP
	#define MANAGEMENT_API_CPP

	#include "casbin/enforcer.h"

	namespace casbin {

	// GetAllSubjects gets the list of subjects that show up in the current policy.
	std::vector<std::string> Enforcer ::GetAllSubjects() {
	return m_model->GetValuesForFieldInPolicyAllTypes("p", 0);
	}

	// GetAllNamedSubjects gets the list of subjects that show up in the current named policy.
	std::vector<std::string> Enforcer ::GetAllNamedSubjects(const std::string& p_type) {
	return m_model->GetValuesForFieldInPolicy("p", p_type, 0);
	}

	// GetAllObjects gets the list of objects that show up in the current policy.
	std::vector<std::string> Enforcer ::GetAllObjects() {
	return m_model->GetValuesForFieldInPolicyAllTypes("p", 1);
	}

	// GetAllNamedObjects gets the list of objects that show up in the current named policy.
	std::vector<std::string> Enforcer ::GetAllNamedObjects(const std::string& p_type) {
	return m_model->GetValuesForFieldInPolicy("p", p_type, 1);
	}

	// GetAllActions gets the list of actions that show up in the current policy.
	std::vector<std::string> Enforcer ::GetAllActions() {
	return m_model->GetValuesForFieldInPolicyAllTypes("p", 2);
	}

	// GetAllNamedActions gets the list of actions that show up in the current named policy.
	std::vector<std::string> Enforcer ::GetAllNamedActions(const std::string& p_type) {
	return m_model->GetValuesForFieldInPolicy("p", p_type, 2);
	}

	// GetAllRoles gets the list of roles that show up in the current policy.
	std::vector<std::string> Enforcer ::GetAllRoles() {
	return m_model->GetValuesForFieldInPolicyAllTypes("g", 1);
	}

	// GetAllNamedRoles gets the list of roles that show up in the current named policy.
	std::vector<std::string> Enforcer ::GetAllNamedRoles(const std::string& p_type) {
	return m_model->GetValuesForFieldInPolicy("g", p_type, 1);
	}

	// GetPolicy gets all the authorization rules in the policy.
	PoliciesValues Enforcer ::GetPolicy() {
	return this->GetNamedPolicy("p");
	}

	// GetFilteredPolicy gets all the authorization rules in the policy, field filters can be specified.
	PoliciesValues Enforcer ::GetFilteredPolicy(int field_index, const std::vector<std::string>& field_values) {
	return this->GetFilteredNamedPolicy("p", field_index, field_values);
	}

	// GetNamedPolicy gets all the authorization rules in the named policy.
	PoliciesValues Enforcer ::GetNamedPolicy(const std::string& p_type) {
	return m_model->GetPolicy("p", p_type);
	}

	// GetFilteredNamedPolicy gets all the authorization rules in the named policy, field filters can be specified.
	PoliciesValues Enforcer ::GetFilteredNamedPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
	return m_model->GetFilteredPolicy("p", p_type, field_index, field_values);
	}

	// GetGroupingPolicy gets all the role inheritance rules in the policy.
	PoliciesValues Enforcer ::GetGroupingPolicy() {
	return this->GetNamedGroupingPolicy("g");
	}

	// GetFilteredGroupingPolicy gets all the role inheritance rules in the policy, field filters can be specified.
	PoliciesValues Enforcer ::GetFilteredGroupingPolicy(int field_index, const std::vector<std::string>& field_values) {
	return this->GetFilteredNamedGroupingPolicy("g", field_index, field_values);
	}

	// GetNamedGroupingPolicy gets all the role inheritance rules in the policy.
	PoliciesValues Enforcer ::GetNamedGroupingPolicy(const std::string& p_type) {
	return m_model->GetPolicy("g", p_type);
	}

	// GetFilteredNamedGroupingPolicy gets all the role inheritance rules in the policy, field filters can be specified.
	PoliciesValues Enforcer ::GetFilteredNamedGroupingPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
	return m_model->GetFilteredPolicy("g", p_type, field_index, field_values);
	}

	// HasPolicy determines whether an authorization rule exists.
	bool Enforcer ::HasPolicy(const std::vector<std::string>& params) {
	return this->HasNamedPolicy("p", params);
	}

	// HasNamedPolicy determines whether a named authorization rule exists.
	bool Enforcer ::HasNamedPolicy(const std::string& p_type, const std::vector<std::string>& params) {
	if (params.size() == 1) {
	std::vector<std::string> str_slice{params[0]};
	return m_model->HasPolicy("p", p_type, str_slice);
	}

	std::vector<std::string> policy;
	for (int i = 0; i < params.size(); i++)
	policy.push_back(params[i]);
	return m_model->HasPolicy("p", p_type, policy);
	}

	// AddPolicy adds an authorization rule to the current policy.
	// If the rule already exists, the function returns false and the rule will not be added.
	// Otherwise the function returns true by adding the new rule.
	bool Enforcer ::AddPolicy(const std::vector<std::string>& params) {
	return this->AddNamedPolicy("p", params);
	}

	// AddPolicies adds authorization rules to the current policy.
	// If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
	// Otherwise the function returns true for the corresponding rule by adding the new rule.
	bool Enforcer ::AddPolicies(const PoliciesValues& rules) {
	return this->AddNamedPolicies("p", rules);
	}

	// AddNamedPolicy adds an authorization rule to the current named policy.
	// If the rule already exists, the function returns false and the rule will not be added.
	// Otherwise the function returns true by adding the new rule.
	bool Enforcer ::AddNamedPolicy(const std::string& p_type, const std::vector<std::string>& params) {
	if (params.size() == 1) {
	std::vector<std::string> str_slice{params[0]};
	return this->addPolicy("p", p_type, str_slice);
	}

	return this->addPolicy("p", p_type, params);
	}

	// AddNamedPolicies adds authorization rules to the current named policy.
	// If the rule already exists, the function returns false for the corresponding rule and the rule will not be added.
	// Otherwise the function returns true for the corresponding by adding the new rule.
	bool Enforcer ::AddNamedPolicies(const std::string& p_type, const PoliciesValues& rules) {
	return this->addPolicies("p", p_type, rules);
	}

	// RemovePolicy removes an authorization rule from the current policy.
	bool Enforcer ::RemovePolicy(const std::vector<std::string>& params) {
	return this->RemoveNamedPolicy("p", params);
	}

	// RemovePolicies removes authorization rules from the current policy.
	bool Enforcer ::RemovePolicies(const PoliciesValues& rules) {
	return this->RemoveNamedPolicies("p", rules);
	}

	// RemoveFilteredPolicy removes an authorization rule from the current policy, field filters can be specified.
	bool Enforcer ::RemoveFilteredPolicy(int field_index, const std::vector<std::string>& field_values) {
	return this->RemoveFilteredNamedPolicy("p", field_index, field_values);
	}

	// RemoveNamedPolicy removes an authorization rule from the current named policy.
	bool Enforcer ::RemoveNamedPolicy(const std::string& p_type, const std::vector<std::string>& params) {
	if (params.size() == 1) {
	std::vector<std::string> str_slice{params[0]};
	return this->removePolicy("p", p_type, str_slice);
	}

	std::vector<std::string> policy;
	for (int i = 0; i < params.size(); i++)
	policy.push_back(params[i]);
	return this->removePolicy("p", p_type, policy);
	}

	// RemoveNamedPolicies removes authorization rules from the current named policy.
	bool Enforcer ::RemoveNamedPolicies(const std::string& p_type, const PoliciesValues& rules) {
	return this->removePolicies("p", p_type, rules);
	}

	// RemoveFilteredNamedPolicy removes an authorization rule from the current named policy, field filters can be specified.
	bool Enforcer ::RemoveFilteredNamedPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
	return this->removeFilteredPolicy("p", p_type, field_index, field_values);
	}

	// HasGroupingPolicy determines whether a role inheritance rule exists.
	bool Enforcer ::HasGroupingPolicy(const std::vector<std::string>& params) {
	return this->HasNamedGroupingPolicy("g", params);
	}

	// HasNamedGroupingPolicy determines whether a named role inheritance rule exists.
	bool Enforcer ::HasNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& params) {
	if (params.size() == 1) {
	std::vector<std::string> str_slice{params[0]};
	return m_model->HasPolicy("g", p_type, str_slice);
	}

	std::vector<std::string> policy;
	for (int i = 0; i < params.size(); i++)
	policy.push_back(params[i]);
	return m_model->HasPolicy("g", p_type, policy);
	}

	// AddGroupingPolicy adds a role inheritance rule to the current policy.
	// If the rule already exists, the function returns false and the rule will not be added.
	// Otherwise the function returns true by adding the new rule.
	bool Enforcer ::AddGroupingPolicy(const std::vector<std::string>& params) {
	return this->AddNamedGroupingPolicy("g", params);
	}

	// AddGroupingPolicies adds role inheritance rulea to the current policy.
	// If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
	// Otherwise the function returns true for the corresponding policy rule by adding the new rule.
	bool Enforcer ::AddGroupingPolicies(const PoliciesValues& rules) {
	return this->AddNamedGroupingPolicies("g", rules);
	}

	// AddNamedGroupingPolicy adds a named role inheritance rule to the current policy.
	// If the rule already exists, the function returns false and the rule will not be added.
	// Otherwise the function returns true by adding the new rule.
	bool Enforcer ::AddNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& params) {
	bool rule_added;
	if (params.size() == 1) {
	std::vector<std::string> str_slice{params[0]};
	rule_added = this->addPolicy("g", p_type, str_slice);
	} else {
	std::vector<std::string> policy;
	for (int i = 0; i < params.size(); i++)
	policy.push_back(params[i]);

	rule_added = this->addPolicy("g", p_type, policy);
	}

	if (m_auto_build_role_links)
	this->BuildIncrementalRoleLinks(policy_add, p_type, PoliciesValues({params}));
	// this->BuildRoleLinks();

	return rule_added;
	}

	// AddNamedGroupingPolicies adds named role inheritance rules to the current policy.
	// If the rule already exists, the function returns false for the corresponding policy rule and the rule will not be added.
	// Otherwise the function returns true for the corresponding policy rule by adding the new rule.
	bool Enforcer ::AddNamedGroupingPolicies(const std::string& p_type, const PoliciesValues& rules) {
	return this->addPolicies("g", p_type, rules);
	}

	// RemoveGroupingPolicy removes a role inheritance rule from the current policy.
	bool Enforcer ::RemoveGroupingPolicy(const std::vector<std::string>& params) {
	return this->RemoveNamedGroupingPolicy("g", params);
	}

	// RemoveGroupingPolicies removes role inheritance rulea from the current policy.
	bool Enforcer ::RemoveGroupingPolicies(const PoliciesValues& rules) {
	return this->RemoveNamedGroupingPolicies("g", rules);
	}

	// RemoveFilteredGroupingPolicy removes a role inheritance rule from the current policy, field filters can be specified.
	bool Enforcer ::RemoveFilteredGroupingPolicy(int field_index, const std::vector<std::string>& field_values) {
	return this->RemoveFilteredNamedGroupingPolicy("g", field_index, field_values);
	}

	// RemoveNamedGroupingPolicy removes a role inheritance rule from the current named policy.
	bool Enforcer ::RemoveNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& params) {
	bool rule_removed;
	if (params.size() == 1) {
	std::vector<std::string> str_slice{params[0]};
	rule_removed = this->removePolicy("g", p_type, str_slice);
	} else {
	std::vector<std::string> policy;
	for (int i = 0; i < params.size(); i++)
	policy.push_back(params[i]);

	rule_removed = this->removePolicy("g", p_type, policy);
	}

	if (m_auto_build_role_links)
	this->BuildRoleLinks();

	return rule_removed;
	}

	// RemoveNamedGroupingPolicies removes role inheritance rules from the current named policy.
	bool Enforcer ::RemoveNamedGroupingPolicies(const std::string& p_type, const PoliciesValues& rules) {
	return this->removePolicies("g", p_type, rules);
	}

	// RemoveFilteredNamedGroupingPolicy removes a role inheritance rule from the current named policy, field filters can be specified.
	bool Enforcer ::RemoveFilteredNamedGroupingPolicy(const std::string& p_type, int field_index, const std::vector<std::string>& field_values) {
	bool rule_removed = this->removeFilteredPolicy("g", p_type, field_index, field_values);

	if (m_auto_build_role_links)
	this->BuildRoleLinks();

	return rule_removed;
	}

	bool Enforcer ::UpdateGroupingPolicy(const std::vector<std::string>& oldRule, const std::vector<std::string>& newRule) {
	return UpdateNamedGroupingPolicy("g", oldRule, newRule);
	}

	bool Enforcer ::UpdateNamedGroupingPolicy(const std::string& p_type, const std::vector<std::string>& oldRule, const std::vector<std::string>& newRule) {
	return this->updatePolicy("g", p_type, oldRule, newRule);
	}

	// UpdatePolicy updates an authorization rule from the current policy.
	bool Enforcer ::UpdatePolicy(const std::vector<std::string>& oldPolicy, const std::vector<std::string>& newPolicy) {
	return UpdateNamedPolicy("p", oldPolicy, newPolicy);
	}

	bool Enforcer ::UpdateNamedPolicy(const std::string& ptype, const std::vector<std::string>& p1, const std::vector<std::string>& p2) {
	return this->updatePolicy("p", ptype, p1, p2);
	}

	// UpdatePolicies updates authorization rules from the current policies.
	bool Enforcer ::UpdatePolicies(const PoliciesValues& oldPolices, const PoliciesValues& newPolicies) {
	return UpdateNamedPolicies("p", oldPolices, newPolicies);
	}

	bool Enforcer ::UpdateNamedPolicies(const std::string& ptype, const PoliciesValues& p1, const PoliciesValues& p2) {
	return this->updatePolicies("p", ptype, p1, p2);
	}

	// AddNamedMatchingFunc add MatchingFunc by ptype RoleManager
	bool Enforcer ::AddNamedMatchingFunc(const std::string& ptype, const std::string& name, casbin::MatchingFunc func) {
	auto default_rm = dynamic_cast<casbin::DefaultRoleManager*>(this->rm.get());
	default_rm->AddMatchingFunc(func);

	return true;
	}

	} // namespace casbin

	#endif // MANAGEMENT_API_CPP