The Tor Browser: parser/html/jArray.h@8bccb770b82d

     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  */

    23 #ifndef jArray_h

    24 #define jArray_h

    26 #include "mozilla/NullPtr.h"

    27 #include "nsDebug.h"

    29 template<class T, class L>

    30 struct staticJArray {

    31   const T* arr;

    32   const L length;

    33   operator T*() { return arr; }

    34   T& operator[] (L const index) { return ((T*)arr)[index]; }

    35   L binarySearch(T const elem) {

    36     L lo = 0;

    37     L hi = length - 1;

    38     while (lo <= hi) {

    39       L mid = (lo + hi) / 2;

    40       if (arr[mid] > elem) {

    41         hi = mid - 1;

    42       } else if (arr[mid] < elem) {

    43         lo = mid + 1;

    44       } else {

    45         return mid;

    46       }

    47     }

    48     return -1;

    49   }

    50 };

    52 template<class T, class L>

    53 struct jArray {

    54   T* arr;

    55   L length;

    56   static jArray<T,L> newJArray(L const len) {

    57     NS_ASSERTION(len >= 0, "Bad length.");

    58     jArray<T,L> newArray = { new T[len], len };

    59     return newArray;

    60   }

    61   operator T*() { return arr; }

    62   T& operator[] (L const index) { return arr[index]; }

    63   void operator=(staticJArray<T,L>& other) {

    64     arr = (T*)other.arr;

    65     length = other.length;

    66   }

    67 };

    69 template<class T, class L>

    70 class autoJArray {

    71   private:

    72     T* arr;

    73   public:

    74     L length;

    75     autoJArray()

    76      : arr(0)

    77      , length(0)

    78     {

    79     }

    80     autoJArray(const jArray<T,L>& other)

    81      : arr(other.arr)

    82      , length(other.length)

    83     {

    84     }

    85     ~autoJArray()

    86     {

    87       delete[] arr;

    88     }

    89     operator T*() { return arr; }

    90     T& operator[] (L const index) { return arr[index]; }

    91     operator jArray<T,L>() {

    92       // WARNING! This makes it possible to goof with buffer ownership!

    93       // This is needed for the getStack and getListOfActiveFormattingElements

    94       // methods to work sensibly.

    95       jArray<T,L> newArray = { arr, length };

    96       return newArray;

    97     }

    98     void operator=(const jArray<T,L>& other) {

    99       delete[] arr;

   100       arr = other.arr;

   101       length = other.length;

   102     }

   103     void operator=(mozilla::NullptrT n) {

   104       // Make assigning null to an array in Java delete the buffer in C++

   105       MOZ_ASSERT(n == nullptr);

   106       delete[] arr;

   107       arr = nullptr;

   108       length = 0;

   109     }

   110 };

   112 #endif // jArray_h

The Tor Browser / file revision