AuthorizationData.cpp [plain text]
#include "AuthorizationData.h"
namespace Authorization {
Right &
Right::overlay(AuthorizationItem &item)
{
return static_cast<Right &>(item);
}
Right *
Right::overlay(AuthorizationItem *item)
{
return static_cast<Right *>(item);
}
Right::Right()
{
name = "";
valueLength = 0;
value = NULL;
flags = 0;
}
Right::Right(AuthorizationString inName, size_t inValueLength, const void *inValue)
{
name = inName;
valueLength = inValueLength;
value = const_cast<void *>(inValue);
}
Right::~Right()
{
}
bool
Right::operator < (const Right &other) const
{
return strcmp(name, other.name) < 0;
}
const AuthorizationRights RightSet::gEmptyRights = { 0, NULL };
RightSet::RightSet(const AuthorizationRights *rights) :
mRights(const_cast<AuthorizationRights *>(rights ? rights : &gEmptyRights))
{
}
RightSet::RightSet(const RightSet &other)
{
mRights = other.mRights;
}
RightSet::~RightSet()
{
}
RightSet::const_reference
RightSet::back() const
{
return static_cast<const_reference>(mRights->items[size() - 1]);
}
MutableRightSet::MutableRightSet(size_t count, const Right &element) :
mCapacity(count)
{
mRights = new AuthorizationRights();
mRights->items = reinterpret_cast<pointer>(malloc(sizeof(Right) * mCapacity));
if (!mRights->items)
{
delete mRights;
throw std::bad_alloc();
}
mRights->count = count;
for (size_type ix = 0; ix < count; ++ix)
mRights->items[ix] = element;
}
MutableRightSet::MutableRightSet(const RightSet &other)
{
size_type count = other.size();
mCapacity = count;
mRights = new AuthorizationRights();
mRights->items = reinterpret_cast<pointer>(malloc(sizeof(Right) * mCapacity));
if (!mRights->items)
{
delete mRights;
throw std::bad_alloc();
}
mRights->count = count;
for (size_type ix = 0; ix < count; ++ix)
mRights->items[ix] = other.mRights->items[ix];
}
MutableRightSet::~MutableRightSet()
{
free(mRights->items);
delete mRights;
}
MutableRightSet &
MutableRightSet::operator = (const RightSet &other)
{
size_type count = other.size();
if (capacity() < count)
grow(count);
mRights->count = count;
for (size_type ix = 0; ix < count; ++ix)
mRights->items[ix] = other.mRights->items[ix];
return *this;
}
void
MutableRightSet::swap(MutableRightSet &other)
{
AuthorizationRights *rights = mRights;
size_t capacity = mCapacity;
mRights = other.mRights;
mCapacity = other.mCapacity;
other.mRights = rights;
other.mCapacity = capacity;
}
MutableRightSet::reference
MutableRightSet::back()
{
return static_cast<reference>(mRights->items[size() - 1]);
}
void
MutableRightSet::push_back(const_reference right)
{
if (size() >= capacity())
grow(capacity() + 1);
mRights->items[mRights->count] = right;
mRights->count++;
}
void
MutableRightSet::pop_back()
{
if (!empty())
mRights->count--;
}
void
MutableRightSet::grow(size_type min_capacity)
{
size_type newCapacity = mCapacity * mCapacity;
if (newCapacity < min_capacity)
newCapacity = min_capacity;
void *newItems = realloc(mRights->items, sizeof(*mRights->items) * newCapacity);
if (!newItems)
throw std::bad_alloc();
mRights->items = reinterpret_cast<pointer>(newItems);
mCapacity = newCapacity;
}
}