parser/html/jArray.h

   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 "mozilla/NullPtr.h"
  27 #include "nsDebug.h"
  28
  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 };
  51
  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 };
  68
  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 #if defined(__clang__)
 104     // clang on OS X 10.7 does not have std::nullptr_t
 105     typedef decltype(nullptr) jArray_nullptr_t;
 106 #elif defined(MOZ_HAVE_CXX11_NULLPTR)
 107     // decltype(nullptr) does not evaluate to std::nullptr_t on GCC 4.6.3
 108     typedef std::nullptr_t jArray_nullptr_t;
 109 #elif defined(__GNUC__)
 110     typedef void* jArray_nullptr_t;
 111 #elif defined(_WIN64)
 112     typedef uint64_t jArray_nullptr_t;
 113 #else
 114     typedef uint32_t jArray_nullptr_t;
 115 #endif
 116     void operator=(jArray_nullptr_t zero) {
 117       // Make assigning null to an array in Java delete the buffer in C++
 118       // MSVC10 does not allow asserting that zero is null.
 119       delete[] arr;
 120       arr = nullptr;
 121       length = 0;
 122     }
 123 };
 124
 125 #endif // jArray_h_