/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/**
* nsPropertyTable allows a set of arbitrary key/value pairs to be stored
* for any number of nodes, in a global hashtable rather than on the nodes
* themselves. Nodes can be any type of object; the hashtable keys are
* nsAtom pointers, and the values are void pointers.
*/
#include "nsPropertyTable.h"
#include "mozilla/MemoryReporting.h"
#include "PLDHashTable.h"
#include "nsError.h"
#include "nsAtom.h"
struct PropertyListMapEntry : public PLDHashEntryHdr {
const void *key;
void *value;
};
//----------------------------------------------------------------------
class nsPropertyTable::PropertyList {
public:
PropertyList(nsAtom *aName, NSPropertyDtorFunc aDtorFunc, void *aDtorData,
bool aTransfer);
~PropertyList();
// Removes the property associated with the given object, and destroys
// the property value
bool DeletePropertyFor(nsPropertyOwner aObject);
// Destroy all remaining properties (without removing them)
void Destroy();
bool Equals(nsAtom *aPropertyName) { return mName == aPropertyName; }
size_t SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf);
RefPtr<nsAtom> mName; // property name
PLDHashTable mObjectValueMap; // map of object/value pairs
NSPropertyDtorFunc mDtorFunc; // property specific value dtor function
void *mDtorData; // pointer to pass to dtor
bool mTransfer; // whether to transfer in
// TransferOrDeleteAllPropertiesFor
PropertyList *mNext;
};
void nsPropertyTable::DeleteAllProperties() {
while (mPropertyList) {
PropertyList *tmp = mPropertyList;
mPropertyList = mPropertyList->mNext;
tmp->Destroy();
delete tmp;
}
}
void nsPropertyTable::DeleteAllPropertiesFor(nsPropertyOwner aObject) {
for (PropertyList *prop = mPropertyList; prop; prop = prop->mNext) {
prop->DeletePropertyFor(aObject);
}
}
nsresult nsPropertyTable::TransferOrDeleteAllPropertiesFor(
nsPropertyOwner aObject, nsPropertyTable *aOtherTable) {
nsresult rv = NS_OK;
for (PropertyList *prop = mPropertyList; prop; prop = prop->mNext) {
if (prop->mTransfer) {
auto entry = static_cast<PropertyListMapEntry *>(
prop->mObjectValueMap.Search(aObject));
if (entry) {
rv = aOtherTable->SetProperty(aObject, prop->mName, entry->value,
prop->mDtorFunc, prop->mDtorData,
prop->mTransfer);
if (NS_FAILED(rv)) {
DeleteAllPropertiesFor(aObject);
aOtherTable->DeleteAllPropertiesFor(aObject);
break;
}
prop->mObjectValueMap.RemoveEntry(entry);
}
} else {
prop->DeletePropertyFor(aObject);
}
}
return rv;
}
void nsPropertyTable::Enumerate(nsPropertyOwner aObject,
NSPropertyFunc aCallback, void *aData) {
PropertyList *prop;
for (prop = mPropertyList; prop; prop = prop->mNext) {
auto entry = static_cast<PropertyListMapEntry *>(
prop->mObjectValueMap.Search(aObject));
if (entry) {
aCallback(const_cast<void *>(aObject.get()), prop->mName, entry->value,
aData);
}
}
}
void nsPropertyTable::EnumerateAll(NSPropertyFunc aCallBack, void *aData) {
for (PropertyList *prop = mPropertyList; prop; prop = prop->mNext) {
for (auto iter = prop->mObjectValueMap.Iter(); !iter.Done(); iter.Next()) {
auto entry = static_cast<PropertyListMapEntry *>(iter.Get());
aCallBack(const_cast<void *>(entry->key), prop->mName, entry->value,
aData);
}
}
}
void *nsPropertyTable::GetPropertyInternal(nsPropertyOwner aObject,
nsAtom *aPropertyName, bool aRemove,
nsresult *aResult) {
NS_PRECONDITION(aPropertyName && aObject, "unexpected null param");
nsresult rv = NS_PROPTABLE_PROP_NOT_THERE;
void *propValue = nullptr;
PropertyList *propertyList = GetPropertyListFor(aPropertyName);
if (propertyList) {
auto entry = static_cast<PropertyListMapEntry *>(
propertyList->mObjectValueMap.Search(aObject));
if (entry) {
propValue = entry->value;
if (aRemove) {
// don't call propertyList->mDtorFunc. That's the caller's job now.
propertyList->mObjectValueMap.RemoveEntry(entry);
}
rv = NS_OK;
}
}
if (aResult) *aResult = rv;
return propValue;
}
nsresult nsPropertyTable::SetPropertyInternal(
nsPropertyOwner aObject, nsAtom *aPropertyName, void *aPropertyValue,
NSPropertyDtorFunc aPropDtorFunc, void *aPropDtorData, bool aTransfer,
void **aOldValue) {
NS_PRECONDITION(aPropertyName && aObject, "unexpected null param");
PropertyList *propertyList = GetPropertyListFor(aPropertyName);
if (propertyList) {
// Make sure the dtor function and data and the transfer flag match
if (aPropDtorFunc != propertyList->mDtorFunc ||
aPropDtorData != propertyList->mDtorData ||
aTransfer != propertyList->mTransfer) {
NS_WARNING("Destructor/data mismatch while setting property");
return NS_ERROR_INVALID_ARG;
}
} else {
propertyList = new PropertyList(aPropertyName, aPropDtorFunc, aPropDtorData,
aTransfer);
propertyList->mNext = mPropertyList;
mPropertyList = propertyList;
}
// The current property value (if there is one) is replaced and the current
// value is destroyed
nsresult result = NS_OK;
auto entry = static_cast<PropertyListMapEntry *>(
propertyList->mObjectValueMap.Add(aObject, mozilla::fallible));
if (!entry) return NS_ERROR_OUT_OF_MEMORY;
// A nullptr entry->key is the sign that the entry has just been allocated
// for us. If it's non-nullptr then we have an existing entry.
if (entry->key) {
if (aOldValue)
*aOldValue = entry->value;
else if (propertyList->mDtorFunc)
propertyList->mDtorFunc(const_cast<void *>(entry->key), aPropertyName,
entry->value, propertyList->mDtorData);
result = NS_PROPTABLE_PROP_OVERWRITTEN;
} else if (aOldValue) {
*aOldValue = nullptr;
}
entry->key = aObject;
entry->value = aPropertyValue;
return result;
}
nsresult nsPropertyTable::DeleteProperty(nsPropertyOwner aObject,
nsAtom *aPropertyName) {
NS_PRECONDITION(aPropertyName && aObject, "unexpected null param");
PropertyList *propertyList = GetPropertyListFor(aPropertyName);
if (propertyList) {
if (propertyList->DeletePropertyFor(aObject)) return NS_OK;
}
return NS_PROPTABLE_PROP_NOT_THERE;
}
nsPropertyTable::PropertyList *nsPropertyTable::GetPropertyListFor(
nsAtom *aPropertyName) const {
PropertyList *result;
for (result = mPropertyList; result; result = result->mNext) {
if (result->Equals(aPropertyName)) {
break;
}
}
return result;
}
//----------------------------------------------------------------------
nsPropertyTable::PropertyList::PropertyList(nsAtom *aName,
NSPropertyDtorFunc aDtorFunc,
void *aDtorData, bool aTransfer)
: mName(aName),
mObjectValueMap(PLDHashTable::StubOps(), sizeof(PropertyListMapEntry)),
mDtorFunc(aDtorFunc),
mDtorData(aDtorData),
mTransfer(aTransfer),
mNext(nullptr) {}
nsPropertyTable::PropertyList::~PropertyList() {}
void nsPropertyTable::PropertyList::Destroy() {
// Enumerate any remaining object/value pairs and destroy the value object.
if (mDtorFunc) {
for (auto iter = mObjectValueMap.Iter(); !iter.Done(); iter.Next()) {
auto entry = static_cast<PropertyListMapEntry *>(iter.Get());
mDtorFunc(const_cast<void *>(entry->key), mName, entry->value, mDtorData);
}
}
}
bool nsPropertyTable::PropertyList::DeletePropertyFor(nsPropertyOwner aObject) {
auto entry =
static_cast<PropertyListMapEntry *>(mObjectValueMap.Search(aObject));
if (!entry) return false;
void *value = entry->value;
mObjectValueMap.RemoveEntry(entry);
if (mDtorFunc)
mDtorFunc(const_cast<void *>(aObject.get()), mName, value, mDtorData);
return true;
}
size_t nsPropertyTable::PropertyList::SizeOfIncludingThis(
mozilla::MallocSizeOf aMallocSizeOf) {
size_t n = aMallocSizeOf(this);
n += mObjectValueMap.ShallowSizeOfExcludingThis(aMallocSizeOf);
return n;
}
size_t nsPropertyTable::SizeOfExcludingThis(
mozilla::MallocSizeOf aMallocSizeOf) const {
size_t n = 0;
for (PropertyList *prop = mPropertyList; prop; prop = prop->mNext) {
n += prop->SizeOfIncludingThis(aMallocSizeOf);
}
return n;
}
size_t nsPropertyTable::SizeOfIncludingThis(
mozilla::MallocSizeOf aMallocSizeOf) const {
return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
}
/* static */
void nsPropertyTable::SupportsDtorFunc(void *aObject, nsAtom *aPropertyName,
void *aPropertyValue, void *aData) {
nsISupports *propertyValue = static_cast<nsISupports *>(aPropertyValue);
NS_IF_RELEASE(propertyValue);
}