nsBaseHashtable.h revision 677833bc953b6cb418c701facbdcf4aa18d6c44e
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* ***** 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
*
* 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 C++ hashtable templates.
*
* The Initial Developer of the Original Code is
* Benjamin Smedberg.
* Portions created by the Initial Developer are Copyright (C) 2002
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either 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 ***** */
#ifndef nsBaseHashtable_h__
#define nsBaseHashtable_h__
#include "nsTHashtable.h"
#include "prlock.h"
#include "nsDebug.h"
/**
* the private nsTHashtable::EntryType class used by nsBaseHashtable
* @see nsTHashtable for the specification of this class
* @see nsBaseHashtable for template parameters
*/
{
};
/**
* templated hashtable for simple data types
* This class manages simple data types that do not need construction or
* destruction. Thread-safety is optional, via a flag in Init()
*
* @param KeyClass a wrapper-class for the hashtable key, see nsHashKeys.h
* for a complete specification.
* @param DataType the datatype stored in the hashtable,
* for example, PRUint32 or nsCOMPtr. If UserDataType is not the same,
* DataType must implicitly cast to UserDataType
* @param UserDataType the user sees, for example PRUint32 or nsISupports*
*/
{
// default constructor+destructor are fine
/**
* Initialize the object.
* @param initSize the initial number of buckets in the hashtable,
* default 16
* locking on all class methods
* @return PR_TRUE if the object was initialized properly.
*/
/**
* Check whether the table has been initialized.
* This function is especially useful for static hashtables.
* @return PR_TRUE if the table has been initialized.
*/
/**
* Return the number of entries in the table.
* @return number of entries
*/
/**
* retrieve the value for a key.
* @param aKey the key to retreive
* @param pData data associated with this key will be placed at this
* pointer. If you only need to check if the key exists, pData
* may be null.
* @return PR_TRUE if the key exists. If key does not exist, pData is not
* modified.
*/
{
if (!ent)
return PR_FALSE;
if (pData)
return PR_TRUE;
}
/**
* put a new value for the associated key
* @param aKey the key to put
* @param aData the new data
* @return always PR_TRUE, unless memory allocation failed
*/
{
if (!ent)
return PR_FALSE;
return PR_TRUE;
}
/**
* remove the data for the associated key
* @param aKey the key to remove from the hashtable
*/
/**
* function type provided by the application for enumeration.
* @param aKey the key being enumerated
* @param aData data being enumerated
* @parm userArg passed unchanged from Enumerate
* @return either
* @link PLDHashOperator::PL_DHASH_NEXT PL_DHASH_NEXT @endlink or
* @link PLDHashOperator::PL_DHASH_STOP PL_DHASH_STOP @endlink
*/
typedef PLDHashOperator
void* userArg);
/**
* enumerate entries in the hashtable, without allowing changes
* this function read-locks the hashtable, so other threads may read keys
* at the same time in multi-thread environments.
* @param enumFunc enumeration callback
* @param userArg passed unchanged to the EnumReadFunction
*/
{
"nsBaseHashtable was not initialized properly.");
&enumData);
}
/**
* function type provided by the application for enumeration.
* @param aKey the key being enumerated
* @param aData Reference to data being enumerated, may be altered. e.g. for
* nsInterfaceHashtable this is an nsCOMPtr reference...
* @parm userArg passed unchanged from Enumerate
* @return bitflag combination of
* @link PLDHashOperator::PL_DHASH_REMOVE @endlink,
* @link PLDHashOperator::PL_DHASH_NEXT PL_DHASH_NEXT @endlink, or
* @link PLDHashOperator::PL_DHASH_STOP PL_DHASH_STOP @endlink
*/
typedef PLDHashOperator
void* userArg);
/**
* enumerate entries in the hashtable, allowing changes. This
* functions write-locks the hashtable.
* @param enumFunc enumeration callback
* @param userArg passed unchanged to the EnumFunction
*/
{
"nsBaseHashtable was not initialized properly.");
&enumData);
}
/**
* reset the hashtable, removing all entries
*/
/**
* used internally during EnumerateRead. Allocated on the stack.
* @param func the enumerator passed to EnumerateRead
* @param userArg the userArg passed to EnumerateRead
*/
struct s_EnumReadArgs
{
void* userArg;
};
void *arg);
struct s_EnumArgs
{
void* userArg;
};
void *arg);
};
/**
* This class is a thread-safe version of nsBaseHashtable.
*/
{
typedef typename
typedef typename
typedef typename
typedef typename
void Clear();
};
//
// nsBaseHashtableET definitions
//
{ }
{ }
{ }
//
// nsBaseHashtable definitions
//
{
"PL_DHASH_REMOVE return during const enumeration; ignoring.");
if (res & PL_DHASH_STOP)
return PL_DHASH_STOP;
return PL_DHASH_NEXT;
}
{
}
//
// nsBaseHashtableMT definitions
//
{
}
{
return PR_FALSE;
}
{
return count;
}
UserDataType* pData) const
{
return res;
}
{
return res;
}
void
{
}
{
return count;
}
{
return count;
}
void
{
}
#endif // nsBaseHashtable_h__