mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-16 23:05:42 +00:00
111 lines
3.1 KiB
C++
111 lines
3.1 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* 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/
|
|
*
|
|
* 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 Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
|
|
#ifndef _SEQUENCE_H_
|
|
#define _SEQUENCE_H_
|
|
|
|
#include "Fundamentals.h"
|
|
#include "Memory.h"
|
|
|
|
template <class N, class MEMOPS>
|
|
class Sequence
|
|
{
|
|
protected:
|
|
N *elts;
|
|
Uint32 cnt;
|
|
|
|
public:
|
|
// ----------------------------------------------------------------------------
|
|
// constructors.
|
|
|
|
Sequence() : elts(NULL), cnt(0) {}
|
|
Sequence(Uint32 count) : elts(NULL), cnt(0) { reserve(count); }
|
|
~Sequence() { if (elts) MEMOPS::free(elts); }
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// copy.
|
|
|
|
Sequence(const Sequence<N, MEMOPS>& x) : elts(NULL), cnt(0)
|
|
{
|
|
Uint32 x_count = x.count();
|
|
const N *src = x.elements();
|
|
reserve(x_count);
|
|
N *dst = elts;
|
|
while (x_count--) *dst++ = *src++;
|
|
}
|
|
|
|
Sequence<N, MEMOPS>& operator=(const Sequence<N, MEMOPS>& x)
|
|
{
|
|
Uint32 x_count = x.count();
|
|
const N *src = x.elements();
|
|
N *dst;
|
|
|
|
if ((&x == this) || (x_count == 0))
|
|
return *this;
|
|
|
|
reserve(x_count);
|
|
dst = elts;
|
|
while (x_count--) *dst++ = *src++; // copy the elements.
|
|
return *this;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// memory management.
|
|
|
|
void reserve(Uint32 amount)
|
|
{
|
|
if (cnt < amount) {
|
|
if (elts) MEMOPS::free(elts);
|
|
elts = (N*)MEMOPS::alloc(amount * sizeof(N*));
|
|
cnt = amount;
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// pointers on the elements.
|
|
|
|
N *elements() { return elts; }
|
|
const N *elements() const { return elts; }
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// number of elements and the actual capacity.
|
|
|
|
unsigned char empty() const { return cnt == 0; }
|
|
Uint32 count() const { return cnt; }
|
|
|
|
// ----------------------------------------------------------------------------
|
|
// add, remove, get element
|
|
|
|
N& operator[](Uint32 index) { assert(index < count()); return elts[index]; }
|
|
const N& operator[](Uint32 index) const { assert(index < count()); return elts[index]; }
|
|
|
|
void fill(const N& element)
|
|
{
|
|
N* src = elts;
|
|
Uint32 i = cnt;
|
|
while (i--) *src++ = element;
|
|
}
|
|
};
|
|
|
|
|
|
#endif /* _SEQUENCE_H_ */
|