/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; c-file-offsets: ((substatement-open . 0)) -*- */
/* ***** 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 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 ***** */
#ifndef nsVoidArray_h___
#define nsVoidArray_h___
//#define DEBUG_VOIDARRAY 1
#include "nscore.h"
#include "nsAString.h"
// Comparator callback function for sorting array values.
// Enumerator callback function. Return PR_FALSE to stop
/// A basic zero-based array of void*'s that manages its own memory
nsVoidArray();
virtual ~nsVoidArray();
}
// returns the max number that can be held without allocating
}
{
}
// This both asserts and bounds-checks, because (1) we don't want
// people to write bad code, but (2) we don't want to change it to
// crashing for backwards compatibility. See bug 96108.
{
return SafeElementAt(aIndex);
}
// bounds-checked version
{
{
return nsnull;
}
// The bounds check ensures mImpl is non-null.
}
// useful for doing LRU arrays, sorting, etc
}
}
// Subtly different - Compact() tries to be smart about whether we
// should reallocate the array; SizeTo() just does it.
struct Impl {
/**
* Packed bits. The low 31 bits are the array's size.
* The highest bit is a flag that indicates
* whether or not we "own" mArray, and must free() it when
* destroyed.
*/
/**
* The number of elements in the array
*/
/**
* Array data, padded out to the actual size of the array.
*/
};
#if DEBUG_VOIDARRAY
#endif
enum {
};
// bit twiddlers
}
/// Copy constructors are not allowed
};
// A zero-based array with a bit of automatic internal storage
void Clear();
// The internal storage
};
{
nsStringArray(void);
virtual ~nsStringArray(void);
return nsVoidArray::Count();
}
}
void Clear(void);
void Compact(void) {
nsVoidArray::Compact();
}
void Sort(void);
/// Copy constructors are not allowed
};
{
nsCStringArray(void);
virtual ~nsCStringArray(void);
// Parses a given string using the delimiter passed in. If the array
// already has some elements, items parsed from string will be appended
// to array. For example, array.ParseString("a,b,c", ","); will add strings
// "a", "b" and "c" to the array. Parsing process has the same tokenizing
// behavior as strtok().
return nsVoidArray::Count();
}
}
void Clear(void);
void Compact(void) {
nsVoidArray::Compact();
}
void Sort(void);
void SortIgnoreCase(void);
/// Copy constructors are not allowed
};
//===================================================================
// nsSmallVoidArray is not a general-purpose replacement for
// ns(Auto)VoidArray because there is (some) extra CPU overhead for arrays
// larger than 1 element, though not a lot. It is appropriate for
// space-sensitive uses where sizes of 0 or 1 are moderately common or
// more, and where we're NOT storing arbitrary integers or arbitrary
// pointers.
// NOTE: nsSmallVoidArray can ONLY be used for holding items that always
// have the low bit as a 0 - i.e. element & 1 == 0. This happens to be
// true for allocated and object pointers for all the architectures we run
// on, but conceivably there might be some architectures/compilers for
// which it is NOT true. We know this works for all existing architectures
// because if it didn't then nsCheapVoidArray would have failed. Also note
// that we will ASSERT if this assumption is violated in DEBUG builds.
// XXX we're really re-implementing the whole nsVoidArray interface here -
// some form of abstract class would be useful
// I disagree on the abstraction here. If the point of this class is to be
// as small as possible, and no one will ever derive from it, as I found
// today, there should not be any virtualness to it to avoid the vtable
// ptr overhead.
{
~nsSmallVoidArray();
PRInt32 GetArraySize() const;
// let compiler inline; it may be able to remove these checks
return nsnull;
}
}
void Clear();
void Compact();
#ifdef RT_OS_OS2 /* shut up a million warnings */
#else
#endif
{
}
{
}
void* GetSingleChild() const
{
}
void SetSingleChild(void *aChild);
{
return (nsVoidArray*)mChildren;
}
// A tagged pointer that's either a pointer to a single child
// or a pointer to a vector of multiple children. This is a space
// optimization since a large number of containers have only a
// single child.
void *mChildren;
};
#endif /* nsVoidArray_h___ */