1 : /*
2 : * Copyright (c) 2008-2010 Mozilla Foundation
3 : *
4 : * Permission is hereby granted, free of charge, to any person obtaining a
5 : * copy of this software and associated documentation files (the "Software"),
6 : * to deal in the Software without restriction, including without limitation
7 : * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 : * and/or sell copies of the Software, and to permit persons to whom the
9 : * Software is furnished to do so, subject to the following conditions:
10 : *
11 : * The above copyright notice and this permission notice shall be included in
12 : * all copies or substantial portions of the Software.
13 : *
14 : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15 : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16 : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
17 : * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18 : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
19 : * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
20 : * DEALINGS IN THE SOFTWARE.
21 : */
22 :
23 : #ifndef jArray_h_
24 : #define jArray_h_
25 :
26 : #include "nsDebug.h"
27 :
28 : template<class T, class L>
29 : struct staticJArray {
30 : const T* arr;
31 : const L length;
32 : operator T*() { return arr; }
33 0 : T& operator[] (L const index) { return ((T*)arr)[index]; }
34 124 : L binarySearch(T const elem) {
35 124 : L lo = 0;
36 124 : L hi = length - 1;
37 1072 : while (lo <= hi) {
38 948 : L mid = (lo + hi) / 2;
39 948 : if (arr[mid] > elem) {
40 598 : hi = mid - 1;
41 350 : } else if (arr[mid] < elem) {
42 226 : lo = mid + 1;
43 : } else {
44 124 : return mid;
45 : }
46 : }
47 0 : return -1;
48 : }
49 : };
50 :
51 : template<class T, class L>
52 : struct jArray {
53 : T* arr;
54 : L length;
55 4002 : static jArray<T,L> newJArray(L const len) {
56 4002 : NS_ASSERTION(len >= 0, "Bad length.");
57 8004 : jArray<T,L> newArray = { new T[len], len };
58 : return newArray;
59 : }
60 0 : operator T*() { return arr; }
61 0 : T& operator[] (L const index) { return arr[index]; }
62 0 : void operator=(staticJArray<T,L>& other) {
63 0 : arr = (T*)other.arr;
64 0 : length = other.length;
65 0 : }
66 : };
67 :
68 : template<class T, class L>
69 : class autoJArray {
70 : private:
71 : T* arr;
72 : public:
73 : L length;
74 60 : autoJArray()
75 : : arr(0)
76 60 : , length(0)
77 : {
78 60 : }
79 2832 : autoJArray(const jArray<T,L>& other)
80 : : arr(other.arr)
81 2832 : , length(other.length)
82 : {
83 2832 : }
84 2890 : ~autoJArray()
85 : {
86 2890 : delete[] arr;
87 2890 : }
88 1201 : operator T*() { return arr; }
89 3594 : T& operator[] (L const index) { return arr[index]; }
90 0 : operator jArray<T,L>() {
91 : // WARNING! This makes it possible to goof with buffer ownership!
92 : // This is needed for the getStack and getListOfActiveFormattingElements
93 : // methods to work sensibly.
94 0 : jArray<T,L> newArray = { arr, length };
95 : return newArray;
96 : }
97 1170 : void operator=(const jArray<T,L>& other) {
98 1170 : delete[] arr;
99 1170 : arr = other.arr;
100 1170 : length = other.length;
101 1170 : }
102 1170 : void operator=(L zero) {
103 : // Make assigning null to an array in Java delete the buffer in C++
104 1170 : NS_ASSERTION(!zero, "Non-zero integer assigned to jArray.");
105 1170 : delete[] arr;
106 1170 : arr = 0;
107 1170 : length = 0;
108 1170 : }
109 : };
110 :
111 : #endif // jArray_h_
|