mirror of
https://github.com/VCMP-SqMod/SqMod.git
synced 2024-11-08 08:47:17 +01:00
Concept [WIP]
Privilege management.
This commit is contained in:
Sandu Liviu Catalin
parent
018a2de97b
commit
508d968744
@ -66,6 +66,7 @@ add_library(SqModule MODULE
|
||||
Misc/Functions.cpp Misc/Functions.hpp
|
||||
Misc/Model.cpp Misc/Model.hpp
|
||||
Misc/Player.cpp Misc/Player.hpp
|
||||
Misc/Privilege.cpp Misc/Privilege.hpp
|
||||
Misc/Routine.cpp Misc/Routine.hpp
|
||||
Misc/Signal.cpp Misc/Signal.hpp
|
||||
Misc/Tasks.cpp Misc/Tasks.hpp
|
||||
|
||||
445
module/Misc/Privilege.cpp
Normal file
445
module/Misc/Privilege.cpp
Normal file
@ -0,0 +1,445 @@
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
#include "Misc/Privilege.hpp"
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
namespace SqMod {
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
SQMODE_DECL_TYPENAME(UnitTn, _SC("SqPrivilegeUnit"))
|
||||
SQMODE_DECL_TYPENAME(ClassTn, _SC("SqPrivilegeClass"))
|
||||
SQMODE_DECL_TYPENAME(EntryTn, _SC("SqPrivilegeEntry"))
|
||||
SQMODE_DECL_TYPENAME(ManagerTn, _SC("SqPrivilegeManager"))
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
// Helper value used to identify an index that doesn't exist.
|
||||
static constexpr size_t BAD_POS = ~static_cast< size_t >(0);
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvManager & PvUnit::GetManager() const
|
||||
{
|
||||
return m_Class->GetManager(); // Classes must always have a manager!
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvClass & PvUnit::GetClass() const
|
||||
{
|
||||
return *m_Class; // Units must always have a class!
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void PvUnit::SetClass(PvClass & cls)
|
||||
{
|
||||
cls.AddUnit(*this);
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool PvUnit::Can(const PvEntry & entry) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool PvUnit::Can(const PvEntry & entry, const PvUnit & unit) const
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvUnit * PvClass::GetUnitByID(SQInteger id) const
|
||||
{
|
||||
// Locate the requested unit
|
||||
for (const auto & e : m_Units)
|
||||
{
|
||||
if (e.first == id)
|
||||
{
|
||||
return e.second;
|
||||
}
|
||||
}
|
||||
// No such unit
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvUnit * PvClass::GetUnitByTag(StackStrF & name) const
|
||||
{
|
||||
// Retrieve the hash
|
||||
auto hash = name.HashIt();
|
||||
// Locate the requested unit
|
||||
for (const auto & e : m_Units)
|
||||
{
|
||||
// Does the string hash match?
|
||||
if (e.second->GetTagW().GetHash() == hash &&
|
||||
// Check if the whole string matches as well
|
||||
strncmp(name.mPtr, e.second->GetTagW().mPtr,
|
||||
std::min(name.mLen, e.second->GetTagW().mLen)) == 0)
|
||||
{
|
||||
return e.second; // This is what we're looking for
|
||||
}
|
||||
}
|
||||
// No such unit
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
LightObj PvClass::CreateUnit(SQInteger id, StackStrF & name)
|
||||
{
|
||||
return m_Manager->CreateUnitImpl(id, *this, name).second;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
void PvClass::AddUnit(PvUnit & unit)
|
||||
{
|
||||
// Is this unit already of this class?
|
||||
if (&unit.GetClass() == this)
|
||||
{
|
||||
return; // Nothing to change!
|
||||
}
|
||||
// Remove it from current class
|
||||
unit.GetClass().UnlistUnit(unit);
|
||||
// Enlist it with us
|
||||
EnlistUnit(unit);
|
||||
// Who's your daddy now!
|
||||
unit.m_Class = this;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool PvClass::EnlistUnit(PvUnit & unit)
|
||||
{
|
||||
// Does it exist already?
|
||||
for (const auto & e : m_Units)
|
||||
{
|
||||
if (e.first == unit.GetID())
|
||||
{
|
||||
return false; // Already enlisted here!
|
||||
}
|
||||
}
|
||||
// Enlist it now
|
||||
m_Units.emplace_back(unit.GetID(), &unit);
|
||||
// Enlisted now
|
||||
return true;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
bool PvClass::UnlistUnit(PvUnit & unit)
|
||||
{
|
||||
// Locate the entry in our list
|
||||
auto it = std::find_if(m_Units.cbegin(), m_Units.cend(),
|
||||
[=, id = unit.GetID()](PvUnitList::const_reference e) -> bool {
|
||||
return e.first == id;
|
||||
});
|
||||
// Is this unit enlisted here?
|
||||
if (it == m_Units.end())
|
||||
{
|
||||
return false; // Not enlisted here!
|
||||
}
|
||||
// Remove the unit from out container
|
||||
m_Units.erase(it);
|
||||
// Unlisted now
|
||||
return true;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvEntry * PvManager::GetEntryByID(SQInteger id) const
|
||||
{
|
||||
// Locate the requested entry
|
||||
for (const auto & e : m_Entries)
|
||||
{
|
||||
if (e.first == id)
|
||||
{
|
||||
return e.second;
|
||||
}
|
||||
}
|
||||
// No such entry
|
||||
return nullptr;
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvEntry * PvManager::GetEntryByTag(StackStrF & name) const
|
||||
{
|
||||
// Retrieve the hash
|
||||
auto hash = name.HashIt();
|
||||
// Locate the requested entry
|
||||
for (const auto & e : m_Entries)
|
||||
{
|
||||
// Does the string hash match?
|
||||
if (e.second->GetTagW().GetHash() == hash &&
|
||||
// Check if the whole string matches as well
|
||||
strncmp(name.mPtr, e.second->GetTagW().mPtr,
|
||||
std::min(name.mLen, e.second->GetTagW().mLen)) == 0)
|
||||
{
|
||||
return e.second; // This is what we're looking for
|
||||
}
|
||||
}
|
||||
// No such entry
|
||||
return nullptr;
|
||||
}
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
LightObj PvManager::CreateEntry(SQInteger id, StackStrF & name)
|
||||
{
|
||||
// See if this entry exists already
|
||||
PvEntry * e = GetEntryByID(id);
|
||||
// Return existing entry if already exists
|
||||
if (e != nullptr)
|
||||
{
|
||||
return LightObj(e);
|
||||
}
|
||||
// Create an entry instance
|
||||
LightObj o(DeleteGuard< PvEntry >(new PvEntry(id, std::move(name), this)));
|
||||
// Get a pointer to the new instance
|
||||
e = o.CastI< PvEntry >();
|
||||
// Append the new entry
|
||||
m_Entries.emplace_back(id, e);
|
||||
// Return the resulted object
|
||||
return o;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvClass *PvManager::GetClassByID(SQInteger id) const
|
||||
{
|
||||
// Locate the requested class
|
||||
for (const auto & e : m_Classes)
|
||||
{
|
||||
if (e.first == id)
|
||||
{
|
||||
return e.second;
|
||||
}
|
||||
}
|
||||
// No such class
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvClass * PvManager::GetClassByTag(StackStrF & name) const
|
||||
{
|
||||
// Retrieve the hash
|
||||
auto hash = name.HashIt();
|
||||
// Locate the requested class
|
||||
for (const auto & e : m_Classes)
|
||||
{
|
||||
// Does the string hash match?
|
||||
if (e.second->GetTagW().GetHash() == hash &&
|
||||
// Check if the whole string matches as well
|
||||
strncmp(name.mPtr, e.second->GetTagW().mPtr,
|
||||
std::min(name.mLen, e.second->GetTagW().mLen)) == 0)
|
||||
{
|
||||
return e.second; // This is what we're looking for
|
||||
}
|
||||
}
|
||||
// No such class
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
LightObj PvManager::CreateClass(SQInteger id, StackStrF & name)
|
||||
{
|
||||
// See if this class exists already
|
||||
PvClass * e = GetClassByID(id);
|
||||
// Return existing class if already exists
|
||||
if (e != nullptr)
|
||||
{
|
||||
return LightObj(e);
|
||||
}
|
||||
// Create an class instance
|
||||
LightObj o(DeleteGuard< PvClass >(new PvClass(id, std::move(name), this)));
|
||||
// Get a pointer to the new instance
|
||||
e = o.CastI< PvClass >();
|
||||
// Append the new class
|
||||
m_Classes.emplace_back(id, e);
|
||||
// Return the resulted object
|
||||
return o;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvUnit * PvManager::GetUnitByID(SQInteger id) const
|
||||
{
|
||||
// Locate the requested unit
|
||||
for (const auto & e : m_Units)
|
||||
{
|
||||
if (e.first == id)
|
||||
{
|
||||
return e.second;
|
||||
}
|
||||
}
|
||||
// No such unit
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
PvUnit * PvManager::GetUnitByTag(StackStrF & name) const
|
||||
{
|
||||
// Retrieve the hash
|
||||
auto hash = name.HashIt();
|
||||
// Locate the requested unit
|
||||
for (const auto & e : m_Units)
|
||||
{
|
||||
// Does the string hash match?
|
||||
if (e.second->GetTagW().GetHash() == hash &&
|
||||
// Check if the whole string matches as well
|
||||
strncmp(name.mPtr, e.second->GetTagW().mPtr,
|
||||
std::min(name.mLen, e.second->GetTagW().mLen)) == 0)
|
||||
{
|
||||
return e.second; // This is what we're looking for
|
||||
}
|
||||
}
|
||||
// No such unit
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
LightObj PvManager::CreateUnit(SQInteger id, PvClass & cls, StackStrF & name)
|
||||
{
|
||||
// Return the resulted object
|
||||
return CreateUnitImpl(id, cls, name).second;
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
std::pair< PvUnit *, LightObj > PvManager::CreateUnitImpl(SQInteger id, PvClass & cls, StackStrF & name)
|
||||
{
|
||||
// See if this unit exists already
|
||||
PvUnit * unit = GetUnitByID(id);
|
||||
// Return existing unit if already exists
|
||||
if (unit != nullptr)
|
||||
{
|
||||
// Return the existing unit
|
||||
return std::make_pair(unit, LightObj{unit});
|
||||
}
|
||||
// Create a unit instance
|
||||
LightObj o{DeleteGuard< PvUnit >(new PvUnit(id, std::move(name), &cls))};
|
||||
// Grab the pointer from the object
|
||||
unit = o.CastI< PvUnit >();
|
||||
// Enlist the new unit with this manager
|
||||
m_Units.emplace_back(id, unit);
|
||||
// Enlist the new unit on the specified class
|
||||
cls.EnlistUnit(*unit);
|
||||
// Return the created unit
|
||||
return std::make_pair(unit, std::move(o));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
// ------------------------------------------------------------------------------------------------
|
||||
|
||||
// ================================================================================================
|
||||
void Register_Privilege(HSQUIRRELVM vm)
|
||||
{
|
||||
Table pns(vm);
|
||||
|
||||
pns.Bind(_SC("Unit"),
|
||||
Class< PvUnit, NoConstructor< PvUnit > >(vm, UnitTn::Str)
|
||||
// Meta-methods
|
||||
.SquirrelFunc(_SC("_typename"), &UnitTn::Fn)
|
||||
.Func(_SC("_tostring"), &PvUnit::ToString)
|
||||
// Core Properties
|
||||
.Prop(_SC("ID"), &PvUnit::GetID)
|
||||
.Prop(_SC("Tag"), &PvUnit::GetTag, &PvUnit::SetTag)
|
||||
.Prop(_SC("Data"), &PvUnit::GetData, &PvUnit::SetData)
|
||||
.Prop(_SC("Manager"), &PvUnit::GetManager)
|
||||
.Prop(_SC("Class"), &PvUnit::GetClass, &PvUnit::SetClass)
|
||||
.Prop(_SC("Authority"), &PvUnit::GetAuthority, &PvUnit::SetAuthority)
|
||||
// Core Methods
|
||||
.FmtFunc(_SC("SetTag"), &PvUnit::ApplyTag)
|
||||
// Member Methods
|
||||
.CbFunc(_SC("OnQuery"), &PvUnit::SetOnQuery)
|
||||
.CbFunc(_SC("OnLost"), &PvUnit::SetOnLost)
|
||||
.CbFunc(_SC("OnGained"), &PvUnit::SetOnGained)
|
||||
// Member Overloads
|
||||
.Overload< bool (PvUnit::*)(const PvEntry &) const >
|
||||
(_SC("Can"), &PvUnit::Can)
|
||||
.Overload< bool (PvUnit::*)(const PvEntry &, const PvUnit &) const >
|
||||
(_SC("Can"), &PvUnit::Can)
|
||||
);
|
||||
|
||||
pns.Bind(_SC("Class"),
|
||||
Class< PvClass, NoConstructor< PvClass > >(vm, ClassTn::Str)
|
||||
// Meta-methods
|
||||
.SquirrelFunc(_SC("_typename"), &ClassTn::Fn)
|
||||
.Func(_SC("_tostring"), &PvClass::ToString)
|
||||
// Core Properties
|
||||
.Prop(_SC("ID"), &PvClass::GetID)
|
||||
.Prop(_SC("Tag"), &PvClass::GetTag, &PvClass::SetTag)
|
||||
.Prop(_SC("Data"), &PvClass::GetData, &PvClass::SetData)
|
||||
.Prop(_SC("Parent"), &PvClass::GetParent, &PvClass::SetParent)
|
||||
.Prop(_SC("Manager"), &PvClass::GetManager)
|
||||
// Core Methods
|
||||
.FmtFunc(_SC("SetTag"), &PvClass::ApplyTag)
|
||||
// Member Methods
|
||||
.Func(_SC("AddUnit"), &PvClass::AddUnit)
|
||||
.Func(_SC("GetUnit"), &PvClass::GetUnitByID)
|
||||
.Func(_SC("GetUnitByID"), &PvClass::GetUnitByID)
|
||||
.Func(_SC("HaveUnitWithID"), &PvClass::HaveUnitWithID)
|
||||
.FmtFunc(_SC("GetUnitByTag"), &PvClass::GetUnitByTag)
|
||||
.FmtFunc(_SC("HaveUnitWithTag"), &PvClass::HaveUnitWithTag)
|
||||
.FmtFunc(_SC("CreateUnit"), &PvClass::CreateUnit)
|
||||
.CbFunc(_SC("OnQuery"), &PvClass::SetOnQuery)
|
||||
.CbFunc(_SC("OnLost"), &PvClass::SetOnLost)
|
||||
.CbFunc(_SC("OnGained"), &PvClass::SetOnGained)
|
||||
// Raw functions
|
||||
);
|
||||
|
||||
pns.Bind(_SC("Entry"),
|
||||
Class< PvEntry, NoConstructor< PvEntry > >(vm, EntryTn::Str)
|
||||
// Meta-methods
|
||||
.SquirrelFunc(_SC("_typename"), &EntryTn::Fn)
|
||||
.Func(_SC("_tostring"), &PvEntry::ToString)
|
||||
// Core Properties
|
||||
.Prop(_SC("ID"), &PvEntry::GetID)
|
||||
.Prop(_SC("Tag"), &PvEntry::GetTag, &PvEntry::SetTag)
|
||||
.Prop(_SC("Data"), &PvEntry::GetData, &PvEntry::SetData)
|
||||
.Prop(_SC("Manager"), &PvEntry::GetManager)
|
||||
.Prop(_SC("Brief"), &PvEntry::GetBrief, &PvEntry::SetBrief)
|
||||
.Prop(_SC("Info"), &PvEntry::GetInfo, &PvEntry::SetInfo)
|
||||
.Prop(_SC("Default"), &PvEntry::GetDefault, &PvEntry::SetDefault)
|
||||
// Core Methods
|
||||
.FmtFunc(_SC("SetTag"), &PvEntry::ApplyTag)
|
||||
// Member Methods
|
||||
.FmtFunc(_SC("SetBrief"), &PvEntry::ApplyBrief)
|
||||
.FmtFunc(_SC("SetInfo"), &PvEntry::ApplyInfo)
|
||||
.CbFunc(_SC("OnQuery"), &PvEntry::SetOnQuery)
|
||||
.CbFunc(_SC("OnLost"), &PvEntry::SetOnLost)
|
||||
.CbFunc(_SC("OnGained"), &PvEntry::SetOnGained)
|
||||
// Raw functions
|
||||
);
|
||||
|
||||
pns.Bind(_SC("Manager"),
|
||||
Class< PvManager, NoCopy< PvManager > >(vm, ManagerTn::Str)
|
||||
// Constructors
|
||||
.Ctor()
|
||||
.Ctor< StackStrF & >()
|
||||
// Meta-methods
|
||||
.SquirrelFunc(_SC("_typename"), &ManagerTn::Fn)
|
||||
.Func(_SC("_tostring"), &PvManager::ToString)
|
||||
// Core Properties
|
||||
.Prop(_SC("Tag"), &PvManager::GetTag, &PvManager::SetTag)
|
||||
.Prop(_SC("Data"), &PvManager::GetData, &PvManager::SetData)
|
||||
// Core Methods
|
||||
.FmtFunc(_SC("SetTag"), &PvManager::ApplyTag)
|
||||
// Member Methods
|
||||
.Func(_SC("GetEntry"), &PvManager::GetEntryByID)
|
||||
.Func(_SC("GetEntryByID"), &PvManager::GetEntryByID)
|
||||
.Func(_SC("HaveEntryWithID"), &PvManager::HaveEntryWithID)
|
||||
.FmtFunc(_SC("GetEntryByTag"), &PvManager::GetEntryByTag)
|
||||
.FmtFunc(_SC("HaveEntryWithTag"), &PvManager::HaveEntryWithTag)
|
||||
.FmtFunc(_SC("CreateEntry"), &PvManager::CreateEntry)
|
||||
.Func(_SC("GetClass"), &PvManager::GetClassByID)
|
||||
.Func(_SC("GetClassByID"), &PvManager::GetClassByID)
|
||||
.Func(_SC("HaveClassWithID"), &PvManager::HaveClassWithID)
|
||||
.FmtFunc(_SC("GetClassByTag"), &PvManager::GetClassByTag)
|
||||
.FmtFunc(_SC("HaveClassWithTag"), &PvManager::HaveClassWithTag)
|
||||
.FmtFunc(_SC("CreateClass"), &PvManager::CreateClass)
|
||||
.Func(_SC("GetUnit"), &PvManager::GetUnitByID)
|
||||
.Func(_SC("GetUnitByID"), &PvManager::GetUnitByID)
|
||||
.Func(_SC("HaveUnitWithID"), &PvManager::HaveUnitWithID)
|
||||
.FmtFunc(_SC("GetUnitByTag"), &PvManager::GetUnitByTag)
|
||||
.FmtFunc(_SC("HaveUnitWithTag"), &PvManager::HaveUnitWithTag)
|
||||
.FmtFunc(_SC("CreateUnit"), &PvManager::CreateUnit)
|
||||
.CbFunc(_SC("OnQuery"), &PvManager::SetOnQuery)
|
||||
.CbFunc(_SC("OnLost"), &PvManager::SetOnLost)
|
||||
.CbFunc(_SC("OnGained"), &PvManager::SetOnGained)
|
||||
// Raw functions
|
||||
);
|
||||
|
||||
RootTable(vm).Bind(_SC("SqPrivilege"), pns);
|
||||
}
|
||||
|
||||
} // Namespace:: SqMod
|
||||
1236
module/Misc/Privilege.hpp
Normal file
1236
module/Misc/Privilege.hpp
Normal file
File diff suppressed because it is too large
Load Diff
@ -55,6 +55,7 @@ extern void Register_Constants(HSQUIRRELVM vm);
|
||||
extern void Register_Log(HSQUIRRELVM vm);
|
||||
extern void Register_Core(HSQUIRRELVM vm);
|
||||
extern void Register_Command(HSQUIRRELVM vm);
|
||||
extern void Register_Privilege(HSQUIRRELVM vm);
|
||||
extern void Register_Routine(HSQUIRRELVM vm);
|
||||
extern void RegisterTask(HSQUIRRELVM vm);
|
||||
|
||||
@ -106,6 +107,7 @@ bool RegisterAPI(HSQUIRRELVM vm)
|
||||
Register_Log(vm);
|
||||
Register_Core(vm);
|
||||
Register_Command(vm);
|
||||
Register_Privilege(vm);
|
||||
Register_Routine(vm);
|
||||
RegisterTask(vm);
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user