gecko-dev/xpcom/ds/nsHashtable.h

297 lines
8.7 KiB
C
Raw Normal View History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2012-05-21 11:12:37 +00:00
/* 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/.
* This Original Code has been modified by IBM Corporation.
* Modifications made by IBM described herein are
* Copyright (c) International Business Machines
* Corporation, 2000
*
* Modifications to Mozilla code or documentation
* identified per MPL Section 3.3
*
* Date Modified by Description of modification
* 04/20/2000 IBM Corp. Added PR_CALLBACK for Optlink use in OS2
*/
/**
* nsHashtable is OBSOLETE. Use nsTHashtable or a derivative instead.
*/
#ifndef nsHashtable_h__
#define nsHashtable_h__
#include "pldhash.h"
#include "nscore.h"
#include "nsISupports.h"
#include "nsISupportsImpl.h"
#include "nsStringFwd.h"
class nsIObjectInputStream;
class nsIObjectOutputStream;
struct PRLock;
class nsHashKey {
protected:
2001-11-27 23:55:03 +00:00
nsHashKey(void) {
#ifdef DEBUG
mKeyType = UnknownKey;
#endif
MOZ_COUNT_CTOR(nsHashKey);
}
public:
// Virtual destructor because all hash keys are |delete|d via a
// nsHashKey pointer.
virtual ~nsHashKey(void);
virtual uint32_t HashCode(void) const = 0;
virtual bool Equals(const nsHashKey *aKey) const = 0;
virtual nsHashKey *Clone() const = 0;
virtual nsresult Write(nsIObjectOutputStream* aStream) const;
#ifdef DEBUG
public:
// used for verification that we're casting to the correct key type
enum nsHashKeyType {
UnknownKey,
SupportsKey,
PRUint32Key,
VoidKey,
IDKey,
CStringKey,
StringKey
};
nsHashKeyType GetKeyType() const { return mKeyType; }
protected:
nsHashKeyType mKeyType;
#endif
};
// Enumerator and Read/Write callback functions.
// Return values for nsHashtableEnumFunc
enum {
kHashEnumerateStop = false,
kHashEnumerateNext = true
};
typedef bool
(* nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* aClosure);
typedef nsresult
(* nsHashtableReadEntryFunc)(nsIObjectInputStream *aStream, nsHashKey **aKey,
void **aData);
// NB: may be called with null aKey or aData, to free just one of the two.
typedef void
(* nsHashtableFreeEntryFunc)(nsIObjectInputStream *aStream, nsHashKey *aKey,
void *aData);
typedef nsresult
(* nsHashtableWriteDataFunc)(nsIObjectOutputStream *aStream, void *aData);
class nsHashtable {
protected:
// members
PRLock* mLock;
PLDHashTable mHashtable;
bool mEnumerating;
public:
nsHashtable(uint32_t aSize = 16, bool aThreadSafe = false);
virtual ~nsHashtable();
int32_t Count(void) { return mHashtable.entryCount; }
bool Exists(nsHashKey *aKey);
void *Put(nsHashKey *aKey, void *aData);
void *Get(nsHashKey *aKey);
void *Remove(nsHashKey *aKey);
nsHashtable *Clone();
void Enumerate(nsHashtableEnumFunc aEnumFunc, void* aClosure = nullptr);
void Reset();
void Reset(nsHashtableEnumFunc destroyFunc, void* aClosure = nullptr);
nsHashtable(nsIObjectInputStream* aStream,
nsHashtableReadEntryFunc aReadEntryFunc,
nsHashtableFreeEntryFunc aFreeEntryFunc,
nsresult *aRetVal);
nsresult Write(nsIObjectOutputStream* aStream,
nsHashtableWriteDataFunc aWriteDataFunc) const;
};
////////////////////////////////////////////////////////////////////////////////
// nsObjectHashtable: an nsHashtable where the elements are C++ objects to be
// deleted
typedef void* (* nsHashtableCloneElementFunc)(nsHashKey *aKey, void *aData, void* aClosure);
class nsObjectHashtable : public nsHashtable {
public:
nsObjectHashtable(nsHashtableCloneElementFunc cloneElementFun,
void* cloneElementClosure,
nsHashtableEnumFunc destroyElementFun,
void* destroyElementClosure,
uint32_t aSize = 16, bool threadSafe = false);
~nsObjectHashtable();
nsHashtable *Clone();
void Reset();
bool RemoveAndDelete(nsHashKey *aKey);
protected:
static PLDHashOperator CopyElement(PLDHashTable* table,
PLDHashEntryHdr* hdr,
uint32_t i, void *arg);
nsHashtableCloneElementFunc mCloneElementFun;
void* mCloneElementClosure;
nsHashtableEnumFunc mDestroyElementFun;
void* mDestroyElementClosure;
};
////////////////////////////////////////////////////////////////////////////////
1999-02-06 04:01:23 +00:00
// nsISupportsKey: Where keys are nsISupports objects that get refcounted.
class nsISupportsKey : public nsHashKey {
protected:
nsISupports* mKey;
public:
nsISupportsKey(const nsISupportsKey& aKey) : mKey(aKey.mKey) {
#ifdef DEBUG
mKeyType = SupportsKey;
#endif
NS_IF_ADDREF(mKey);
}
nsISupportsKey(nsISupports* key) {
#ifdef DEBUG
mKeyType = SupportsKey;
#endif
mKey = key;
NS_IF_ADDREF(mKey);
}
~nsISupportsKey(void) {
NS_IF_RELEASE(mKey);
}
uint32_t HashCode(void) const {
return NS_PTR_TO_INT32(mKey);
}
bool Equals(const nsHashKey *aKey) const {
NS_ASSERTION(aKey->GetKeyType() == SupportsKey, "mismatched key types");
return (mKey == ((nsISupportsKey *) aKey)->mKey);
}
nsHashKey *Clone() const {
return new nsISupportsKey(mKey);
}
nsISupportsKey(nsIObjectInputStream* aStream, nsresult *aResult);
nsresult Write(nsIObjectOutputStream* aStream) const;
nsISupports* GetValue() { return mKey; }
1999-02-06 04:01:23 +00:00
};
class nsPRUint32Key : public nsHashKey {
protected:
uint32_t mKey;
public:
nsPRUint32Key(uint32_t key) {
#ifdef DEBUG
mKeyType = PRUint32Key;
#endif
mKey = key;
}
uint32_t HashCode(void) const {
return mKey;
}
bool Equals(const nsHashKey *aKey) const {
return mKey == ((const nsPRUint32Key *) aKey)->mKey;
}
nsHashKey *Clone() const {
return new nsPRUint32Key(mKey);
}
uint32_t GetValue() { return mKey; }
};
// for null-terminated c-strings
class nsCStringKey : public nsHashKey {
public:
// NB: when serializing, NEVER_OWN keys are deserialized as OWN.
enum Ownership {
NEVER_OWN, // very long lived, even clones don't need to copy it.
OWN_CLONE, // as long lived as this key. But clones make a copy.
OWN // to be free'd in key dtor. Clones make their own copy.
};
nsCStringKey(const nsCStringKey& aStrKey);
nsCStringKey(const char* str, int32_t strLen = -1, Ownership own = OWN_CLONE);
nsCStringKey(const nsAFlatCString& str);
nsCStringKey(const nsACString& str);
~nsCStringKey(void);
uint32_t HashCode(void) const;
bool Equals(const nsHashKey* aKey) const;
nsHashKey* Clone() const;
nsCStringKey(nsIObjectInputStream* aStream, nsresult *aResult);
nsresult Write(nsIObjectOutputStream* aStream) const;
// For when the owner of the hashtable wants to peek at the actual
// string in the key. No copy is made, so be careful.
const char* GetString() const { return mStr; }
uint32_t GetStringLength() const { return mStrLen; }
protected:
char* mStr;
uint32_t mStrLen;
Ownership mOwnership;
};
// for null-terminated unicode strings
class nsStringKey : public nsHashKey {
public:
// NB: when serializing, NEVER_OWN keys are deserialized as OWN.
enum Ownership {
NEVER_OWN, // very long lived, even clones don't need to copy it.
OWN_CLONE, // as long lived as this key. But clones make a copy.
OWN // to be free'd in key dtor. Clones make their own copy.
};
nsStringKey(const nsStringKey& aKey);
nsStringKey(const char16_t* str, int32_t strLen = -1, Ownership own = OWN_CLONE);
nsStringKey(const nsAFlatString& str);
nsStringKey(const nsAString& str);
~nsStringKey(void);
uint32_t HashCode(void) const;
bool Equals(const nsHashKey* aKey) const;
nsHashKey* Clone() const;
nsStringKey(nsIObjectInputStream* aStream, nsresult *aResult);
nsresult Write(nsIObjectOutputStream* aStream) const;
// For when the owner of the hashtable wants to peek at the actual
// string in the key. No copy is made, so be careful.
const char16_t* GetString() const { return mStr; }
uint32_t GetStringLength() const { return mStrLen; }
protected:
char16_t* mStr;
uint32_t mStrLen;
Ownership mOwnership;
};
////////////////////////////////////////////////////////////////////////////////
#endif // nsHashtable_h__