1998-10-19 21:48:55 +04:00
|
|
|
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The contents of this file are subject to the Netscape Public
|
|
|
|
* License Version 1.1 (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.mozilla.org/NPL/
|
1998-10-19 21:48:55 +04:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* Software distributed under the License is distributed on an "AS
|
|
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
|
|
* implied. See the License for the specific language governing
|
|
|
|
* rights and limitations under the License.
|
1998-10-19 21:48:55 +04:00
|
|
|
*
|
1999-11-06 06:43:54 +03:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is Netscape
|
1998-10-19 21:48:55 +04:00
|
|
|
* Communications Corporation. Portions created by Netscape are
|
1999-11-06 06:43:54 +03:00
|
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
|
|
* Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
1998-10-19 21:48:55 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef nsHashtable_h__
|
|
|
|
#define nsHashtable_h__
|
|
|
|
|
|
|
|
#include "plhash.h"
|
1999-03-30 12:15:39 +04:00
|
|
|
#include "prlock.h"
|
1998-10-19 21:48:55 +04:00
|
|
|
#include "nsCom.h"
|
|
|
|
|
|
|
|
class NS_COM nsHashKey {
|
|
|
|
protected:
|
|
|
|
nsHashKey(void);
|
|
|
|
public:
|
|
|
|
virtual ~nsHashKey(void);
|
|
|
|
virtual PRUint32 HashValue(void) const = 0;
|
|
|
|
virtual PRBool Equals(const nsHashKey *aKey) const = 0;
|
|
|
|
virtual nsHashKey *Clone(void) const = 0;
|
|
|
|
};
|
|
|
|
|
|
|
|
// Enumerator callback function. Use
|
|
|
|
|
|
|
|
typedef PRBool (*nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* closure);
|
|
|
|
|
|
|
|
class NS_COM nsHashtable {
|
1999-04-16 22:16:21 +04:00
|
|
|
protected:
|
1998-10-19 21:48:55 +04:00
|
|
|
// members
|
|
|
|
PLHashTable *hashtable;
|
1999-03-30 12:15:39 +04:00
|
|
|
PRLock *mLock;
|
1998-10-19 21:48:55 +04:00
|
|
|
|
|
|
|
public:
|
1999-03-30 12:15:39 +04:00
|
|
|
nsHashtable(PRUint32 aSize = 256, PRBool threadSafe = PR_FALSE);
|
1998-10-19 21:48:55 +04:00
|
|
|
~nsHashtable();
|
|
|
|
|
|
|
|
PRInt32 Count(void) { return hashtable->nentries; }
|
1999-03-19 08:51:49 +03:00
|
|
|
PRBool Exists(nsHashKey *aKey);
|
1998-10-19 21:48:55 +04:00
|
|
|
void *Put(nsHashKey *aKey, void *aData);
|
|
|
|
void *Get(nsHashKey *aKey);
|
|
|
|
void *Remove(nsHashKey *aKey);
|
|
|
|
nsHashtable *Clone();
|
|
|
|
void Enumerate(nsHashtableEnumFunc aEnumFunc, void* closure = NULL);
|
1999-02-03 22:35:11 +03:00
|
|
|
void Reset();
|
1999-07-31 09:41:54 +04:00
|
|
|
void Reset(nsHashtableEnumFunc destroyFunc, void* closure = NULL);
|
1998-10-19 21:48:55 +04:00
|
|
|
};
|
|
|
|
|
1999-07-28 11:56:28 +04:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsObjectHashtable: an nsHashtable where the elements are C++ objects to be
|
|
|
|
// deleted
|
|
|
|
|
|
|
|
typedef void* (*nsHashtableCloneElementFunc)(nsHashKey *aKey, void *aData, void* closure);
|
|
|
|
|
|
|
|
class NS_COM nsObjectHashtable : public nsHashtable {
|
|
|
|
public:
|
|
|
|
nsObjectHashtable(nsHashtableCloneElementFunc cloneElementFun,
|
|
|
|
void* cloneElementClosure,
|
|
|
|
nsHashtableEnumFunc destroyElementFun,
|
|
|
|
void* destroyElementClosure,
|
|
|
|
PRUint32 aSize = 256, PRBool threadSafe = PR_FALSE);
|
|
|
|
~nsObjectHashtable();
|
|
|
|
|
|
|
|
nsHashtable *Clone();
|
|
|
|
void Reset();
|
1999-08-03 03:55:03 +04:00
|
|
|
PRBool RemoveAndDelete(nsHashKey *aKey);
|
1999-07-28 11:56:28 +04:00
|
|
|
|
|
|
|
protected:
|
|
|
|
static PR_CALLBACK PRIntn CopyElement(PLHashEntry *he, PRIntn i, void *arg);
|
|
|
|
|
|
|
|
nsHashtableCloneElementFunc mCloneElementFun;
|
|
|
|
void* mCloneElementClosure;
|
|
|
|
nsHashtableEnumFunc mDestroyElementFun;
|
|
|
|
void* mDestroyElementClosure;
|
|
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsSupportsHashtable: an nsHashtable where the elements are nsISupports*
|
|
|
|
|
|
|
|
class NS_COM nsSupportsHashtable : public nsHashtable {
|
|
|
|
public:
|
|
|
|
nsSupportsHashtable(PRUint32 aSize = 256, PRBool threadSafe = PR_FALSE)
|
|
|
|
: nsHashtable(aSize, threadSafe) {}
|
|
|
|
~nsSupportsHashtable();
|
|
|
|
|
|
|
|
void *Put(nsHashKey *aKey, void *aData);
|
|
|
|
void *Get(nsHashKey *aKey);
|
|
|
|
void *Remove(nsHashKey *aKey);
|
|
|
|
nsHashtable *Clone();
|
|
|
|
void Reset();
|
|
|
|
};
|
|
|
|
|
1999-01-27 05:02:22 +03:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
1999-02-06 07:01:23 +03:00
|
|
|
// nsISupportsKey: Where keys are nsISupports objects that get refcounted.
|
|
|
|
|
|
|
|
#include "nsISupports.h"
|
|
|
|
|
|
|
|
class nsISupportsKey : public nsHashKey {
|
1999-04-16 22:16:21 +04:00
|
|
|
protected:
|
1999-03-09 12:44:27 +03:00
|
|
|
nsISupports* mKey;
|
1999-02-06 07:01:23 +03:00
|
|
|
|
|
|
|
public:
|
1999-03-09 12:44:27 +03:00
|
|
|
nsISupportsKey(nsISupports* key) {
|
|
|
|
mKey = key;
|
|
|
|
NS_IF_ADDREF(mKey);
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
~nsISupportsKey(void) {
|
|
|
|
NS_IF_RELEASE(mKey);
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
PRUint32 HashValue(void) const {
|
|
|
|
return (PRUint32)mKey;
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
PRBool Equals(const nsHashKey *aKey) const {
|
|
|
|
return (mKey == ((nsISupportsKey *) aKey)->mKey);
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
nsHashKey *Clone(void) const {
|
|
|
|
return new nsISupportsKey(mKey);
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsVoidKey: Where keys are void* objects that don't get refcounted.
|
|
|
|
|
|
|
|
class nsVoidKey : public nsHashKey {
|
1999-04-16 22:16:21 +04:00
|
|
|
protected:
|
1999-03-09 12:44:27 +03:00
|
|
|
const void* mKey;
|
1999-02-06 07:01:23 +03:00
|
|
|
|
|
|
|
public:
|
1999-03-09 12:44:27 +03:00
|
|
|
nsVoidKey(const void* key) {
|
|
|
|
mKey = key;
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
PRUint32 HashValue(void) const {
|
|
|
|
return (PRUint32)mKey;
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
PRBool Equals(const nsHashKey *aKey) const {
|
|
|
|
return (mKey == ((const nsVoidKey *) aKey)->mKey);
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
nsHashKey *Clone(void) const {
|
|
|
|
return new nsVoidKey(mKey);
|
|
|
|
}
|
1999-02-06 07:01:23 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsIDKey: Where keys are nsIDs (e.g. nsIID, nsCID).
|
1999-01-27 05:02:22 +03:00
|
|
|
|
|
|
|
#include "nsID.h"
|
|
|
|
|
1999-02-06 07:01:23 +03:00
|
|
|
class nsIDKey : public nsHashKey {
|
1999-04-16 22:16:21 +04:00
|
|
|
protected:
|
1999-03-09 12:44:27 +03:00
|
|
|
nsID mID;
|
1999-01-27 05:02:22 +03:00
|
|
|
|
|
|
|
public:
|
1999-03-09 12:44:27 +03:00
|
|
|
nsIDKey(const nsID &aID) {
|
|
|
|
mID = aID;
|
|
|
|
}
|
1999-01-27 05:02:22 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
PRUint32 HashValue(void) const {
|
|
|
|
return mID.m0;
|
|
|
|
}
|
1999-01-27 05:02:22 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
PRBool Equals(const nsHashKey *aKey) const {
|
|
|
|
return (mID.Equals(((const nsIDKey *) aKey)->mID));
|
|
|
|
}
|
1999-01-27 05:02:22 +03:00
|
|
|
|
1999-03-09 12:44:27 +03:00
|
|
|
nsHashKey *Clone(void) const {
|
|
|
|
return new nsIDKey(mID);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
1999-07-22 06:11:04 +04:00
|
|
|
// nsStringKey: Where keys are PRUnichar* or char*
|
1999-03-19 08:51:49 +03:00
|
|
|
// Some uses: hashing ProgIDs, filenames, URIs
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-07-22 06:11:04 +04:00
|
|
|
#include "nsString.h"
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-07-22 06:11:04 +04:00
|
|
|
class NS_COM nsStringKey : public nsHashKey {
|
1999-04-16 22:16:21 +04:00
|
|
|
protected:
|
1999-07-22 06:11:04 +04:00
|
|
|
nsAutoString mStr;
|
1999-03-09 12:44:27 +03:00
|
|
|
|
|
|
|
public:
|
1999-07-22 06:11:04 +04:00
|
|
|
nsStringKey(const char* str);
|
|
|
|
nsStringKey(const PRUnichar* str);
|
2000-03-12 14:10:07 +03:00
|
|
|
nsStringKey(const nsString& str);
|
|
|
|
nsStringKey(const nsCString& str);
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-07-22 06:11:04 +04:00
|
|
|
~nsStringKey(void);
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-03-19 09:18:08 +03:00
|
|
|
PRUint32 HashValue(void) const;
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-03-19 09:18:08 +03:00
|
|
|
PRBool Equals(const nsHashKey* aKey) const;
|
1999-03-19 08:51:49 +03:00
|
|
|
|
1999-03-19 09:18:08 +03:00
|
|
|
nsHashKey* Clone() const;
|
1999-03-09 12:44:27 +03:00
|
|
|
|
1999-08-09 09:02:25 +04:00
|
|
|
// 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 nsString& GetString() const;
|
1999-01-27 05:02:22 +03:00
|
|
|
};
|
|
|
|
|
1999-11-16 06:10:54 +03:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// nsOpaqueKey: Where keys are opaque byte-array blobs
|
|
|
|
|
|
|
|
#include "nsString.h"
|
|
|
|
|
|
|
|
class NS_COM nsOpaqueKey : public nsHashKey {
|
|
|
|
protected:
|
|
|
|
const char* mOpaqueKey; // Byte array of opaque data
|
|
|
|
PRUint32 mKeyLength; // Length, in bytes, of mOpaqueKey
|
|
|
|
|
|
|
|
public:
|
|
|
|
// Note opaque keys are not copied by this constructor. If you want a private
|
|
|
|
// copy in each hash key, you must create one and pass it in to this function.
|
|
|
|
nsOpaqueKey(const char* aOpaqueKey, PRUint32 aKeyLength);
|
|
|
|
|
|
|
|
~nsOpaqueKey(void);
|
|
|
|
|
|
|
|
PRUint32 HashValue(void) const;
|
|
|
|
PRBool Equals(const nsHashKey* aKey) const;
|
|
|
|
nsHashKey* Clone() const;
|
|
|
|
|
|
|
|
// For when the owner of the hashtable wants to peek at the actual
|
|
|
|
// opaque array in the key. No copy is made, so be careful.
|
|
|
|
const char* GetKey() const;
|
|
|
|
PRUint32 GetKeyLength() const;
|
|
|
|
};
|
1999-07-22 06:11:04 +04:00
|
|
|
|
1998-10-19 21:48:55 +04:00
|
|
|
#endif
|