The Tor Browser: comparison xpcom/ds/nsHashtable.h

--1:000000000000
+:e99aed003364
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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:
+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;
+};
+////////////////////////////////////////////////////////////////////////////////
+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;
+};
+////////////////////////////////////////////////////////////////////////////////
+#endif // nsHashtable_h__

The Tor Browser / file comparison

comparison: xpcom/ds/nsHashtable.h

xpcom/ds/nsHashtable.h