Adding upstream version 6.0.4-dfsg.upstream/6.0.4-dfsgupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 454 insertions, 0 deletions

diff --git a/src/libs/xpcom18a4/xpcom/ds/nsHashtable.h b/src/libs/xpcom18a4/xpcom/ds/nsHashtable.h
new file mode 100644
index 00000000..21ce9028
--- /dev/null
+++ b/src/libs/xpcom18a4/xpcom/ds/nsHashtable.h
@@ -0,0 +1,454 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* ***** BEGIN LICENSE BLOCK *****
+ * Version: MPL 1.1/GPL 2.0/LGPL 2.1
+ *
+ * The contents of this file are subject to the Mozilla 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/MPL/
+ *
+ * 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.
+ *
+ * The Original Code is mozilla.org code.
+ *
+ * The Initial Developer of the Original Code is
+ * Netscape Communications Corporation.
+ * Portions created by the Initial Developer are Copyright (C) 1998
+ * the Initial Developer. All Rights Reserved.
+ *
+ * Contributor(s):
+ *
+ * Alternatively, the contents of this file may be used under the terms of
+ * either of the GNU General Public License Version 2 or later (the "GPL"),
+ * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ * in which case the provisions of the GPL or the LGPL are applicable instead
+ * of those above. If you wish to allow use of your version of this file only
+ * under the terms of either the GPL or the LGPL, and not to allow others to
+ * use your version of this file under the terms of the MPL, indicate your
+ * decision by deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL or the LGPL. If you do not delete
+ * the provisions above, a recipient may use your version of this file under
+ * the terms of any one of the MPL, the GPL or the LGPL.
+ *
+ * ***** END LICENSE BLOCK *****
+ * 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 "prlock.h"
+#include "nscore.h"
+#include "nsString.h"
+#include "nsISupportsBase.h"
+#include "nsTraceRefcnt.h"
+
+class nsIObjectInputStream;
+class nsIObjectOutputStream;
+
+class nsHashtable;
+class nsStringKey;
+
+class NS_COM nsHashKey {
+  protected:
+    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 PRUint32 HashCode(void) const = 0;
+    virtual PRBool 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      = PR_FALSE,
+    kHashEnumerateNext      = PR_TRUE,
+    kHashEnumerateRemove    = 2
+};
+
+typedef PRIntn
+(*PR_CALLBACK nsHashtableEnumFunc)(nsHashKey *aKey, void *aData, void* aClosure);
+
+typedef nsresult
+(*PR_CALLBACK 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
+(*PR_CALLBACK nsHashtableFreeEntryFunc)(nsIObjectInputStream *aStream,
+                                        nsHashKey *aKey,
+                                        void *aData);
+
+typedef nsresult
+(*PR_CALLBACK nsHashtableWriteDataFunc)(nsIObjectOutputStream *aStream,
+                                        void *aData);
+
+class NS_COM nsHashtable {
+  protected:
+    // members  
+    PRLock*         mLock;
+    PLDHashTable    mHashtable;
+    PRBool          mEnumerating;
+
+  public:
+    nsHashtable(PRUint32 aSize = 16, PRBool threadSafe = PR_FALSE);
+    virtual ~nsHashtable();
+
+    PRInt32 Count(void) { return mHashtable.entryCount; }
+    PRBool 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 = NULL);
+    void Reset();
+    void Reset(nsHashtableEnumFunc destroyFunc, void* aClosure = NULL);
+
+    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* (*PR_CALLBACK nsHashtableCloneElementFunc)(nsHashKey *aKey, void *aData, void* aClosure);
+
+class NS_COM nsObjectHashtable : public nsHashtable {
+  public:
+    nsObjectHashtable(nsHashtableCloneElementFunc cloneElementFun,
+                      void* cloneElementClosure,
+                      nsHashtableEnumFunc destroyElementFun,
+                      void* destroyElementClosure,
+                      PRUint32 aSize = 16, PRBool threadSafe = PR_FALSE);
+    ~nsObjectHashtable();
+
+    nsHashtable *Clone();
+    void Reset();
+    PRBool RemoveAndDelete(nsHashKey *aKey);
+
+  protected:
+    static PLDHashOperator PR_CALLBACK CopyElement(PLDHashTable* table,
+                                                   PLDHashEntryHdr* hdr,
+                                                   PRUint32 i, void *arg);
+    
+    nsHashtableCloneElementFunc mCloneElementFun;
+    void*                       mCloneElementClosure;
+    nsHashtableEnumFunc         mDestroyElementFun;
+    void*                       mDestroyElementClosure;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// nsSupportsHashtable: an nsHashtable where the elements are nsISupports*
+
+class nsISupports;
+
+class NS_COM nsSupportsHashtable
+  : private nsHashtable
+{
+  public:
+    typedef PRBool (* PR_CALLBACK EnumFunc) (nsHashKey *aKey, void *aData, void* aClosure);
+
+    nsSupportsHashtable(PRUint32 aSize = 16, PRBool threadSafe = PR_FALSE)
+      : nsHashtable(aSize, threadSafe) {}
+    ~nsSupportsHashtable();
+
+    PRInt32 Count(void) {
+        return nsHashtable::Count();
+    }
+    PRBool Exists(nsHashKey *aKey) {
+        return nsHashtable::Exists (aKey);
+    }
+    PRBool Put(nsHashKey *aKey,
+               nsISupports *aData,
+               nsISupports **value = nsnull);
+    nsISupports* Get(nsHashKey *aKey);
+    PRBool Remove(nsHashKey *aKey, nsISupports **value = nsnull);
+    nsHashtable *Clone();
+    void Enumerate(EnumFunc aEnumFunc, void* aClosure = NULL) {
+        nsHashtable::Enumerate(aEnumFunc, aClosure);
+    }
+    void Reset();
+
+  private:
+    static PRBool PR_CALLBACK ReleaseElement(nsHashKey *, void *, void *);
+    static PLDHashOperator PR_CALLBACK EnumerateCopy(PLDHashTable*,
+                                                     PLDHashEntryHdr* hdr,
+                                                     PRUint32 i, void *arg);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// nsISupportsKey: Where keys are nsISupports objects that get refcounted.
+
+#include "nsISupports.h"
+
+class NS_COM 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);
+    }
+    
+    PRUint32 HashCode(void) const {
+        return NS_PTR_TO_INT32(mKey);
+    }
+
+    PRBool 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;
+};
+
+
+class nsPRUint32Key : public nsHashKey {
+protected:
+    PRUint32 mKey;
+public:
+    nsPRUint32Key(PRUint32 key) {
+#ifdef DEBUG
+        mKeyType = PRUint32Key;
+#endif
+        mKey = key;
+    }
+
+    PRUint32 HashCode(void) const {
+        return mKey;
+    }
+
+    PRBool Equals(const nsHashKey *aKey) const {
+        return mKey == ((const nsPRUint32Key *) aKey)->mKey;
+    }
+    nsHashKey *Clone() const {
+        return new nsPRUint32Key(mKey);
+    }
+    PRUint32 GetValue() { return mKey; }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// nsVoidKey: Where keys are void* objects that don't get refcounted.
+
+class nsVoidKey : public nsHashKey {
+  protected:
+    void* mKey;
+    
+  public:
+    nsVoidKey(const nsVoidKey& aKey) : mKey(aKey.mKey) {
+#ifdef DEBUG
+        mKeyType = aKey.mKeyType;
+#endif
+    }
+
+    nsVoidKey(void* key) {
+#ifdef DEBUG
+        mKeyType = VoidKey;
+#endif
+        mKey = key;
+    }
+    
+    PRUint32 HashCode(void) const {
+        return NS_PTR_TO_INT32(mKey);
+    }
+
+    PRBool Equals(const nsHashKey *aKey) const {
+        NS_ASSERTION(aKey->GetKeyType() == VoidKey, "mismatched key types");
+        return (mKey == ((const nsVoidKey *) aKey)->mKey);
+    }
+
+    nsHashKey *Clone() const {
+        return new nsVoidKey(mKey);
+    }
+
+    void* GetValue() { return mKey; }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+// nsIDKey: Where keys are nsIDs (e.g. nsIID, nsCID).
+
+#include "nsID.h"
+
+class NS_COM nsIDKey : public nsHashKey {
+  protected:
+    nsID mID;
+    
+  public:
+    nsIDKey(const nsIDKey& aKey) : mID(aKey.mID) {
+#ifdef DEBUG
+          mKeyType = IDKey;
+#endif
+    }
+
+    nsIDKey(const nsID &aID) {
+#ifdef DEBUG
+        mKeyType = IDKey;
+#endif
+        mID = aID;
+    }
+    
+    PRUint32 HashCode(void) const {
+        return mID.m0;
+    }
+
+    PRBool Equals(const nsHashKey *aKey) const {
+        NS_ASSERTION(aKey->GetKeyType() == IDKey, "mismatched key types");
+        return (mID.Equals(((const nsIDKey *) aKey)->mID));
+    }
+
+    nsHashKey *Clone() const {
+        return new nsIDKey(mID);
+    }
+
+    nsIDKey(nsIObjectInputStream* aStream, nsresult *aResult);
+    nsresult Write(nsIObjectOutputStream* aStream) const;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+#include "nsString.h"
+
+// for null-terminated c-strings
+class NS_COM 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, PRInt32 strLen = -1, Ownership own = OWN_CLONE);
+    nsCStringKey(const nsAFlatCString& str);
+    nsCStringKey(const nsACString& str);
+    ~nsCStringKey(void);
+
+    PRUint32 HashCode(void) const;
+    PRBool 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; }
+    PRUint32 GetStringLength() const { return mStrLen; }
+
+  protected:
+    char*       mStr;
+    PRUint32    mStrLen;
+    Ownership   mOwnership;
+};
+
+// for null-terminated unicode strings
+class NS_COM 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 PRUnichar* str, PRInt32 strLen = -1, Ownership own = OWN_CLONE);
+    nsStringKey(const nsAFlatString& str);
+    nsStringKey(const nsAString& str);
+    ~nsStringKey(void);
+
+    PRUint32 HashCode(void) const;
+    PRBool 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 PRUnichar* GetString() const { return mStr; }
+    PRUint32 GetStringLength() const { return mStrLen; }
+
+  protected:
+    PRUnichar*  mStr;
+    PRUint32    mStrLen;
+    Ownership   mOwnership;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+#endif // nsHashtable_h__