parser/html/jArray.h

   1 /*
   2  * Copyright (c) 2008-2015 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 <array>
  27 #include "mozilla/Attributes.h"
  28 #include "mozilla/BinarySearch.h"
  29
  30 template <class T, class L>
  31 struct staticJArray {
  32   const T* arr;
  33   const L length;
  34   operator T*() { return arr; }
  35   T& operator[](L const index) {
  36     MOZ_ASSERT(index >= 0, "Array access with negative index.");
  37     MOZ_ASSERT(index < length, "Array index out of bounds.");
  38     return ((T*)arr)[index];
  39   }
  40   L binarySearch(T const elem) {
  41     size_t idx;
  42     bool found = mozilla::BinarySearch(arr, 0, length, elem, &idx);
  43     return found ? idx : -1;
  44   }
  45 };
  46
  47 template <class T, class L>
  48 class autoJArray;
  49
  50 template <class T, class L>
  51 class jArray {
  52   friend class autoJArray<T, L>;
  53
  54  private:
  55   T* arr;
  56
  57  public:
  58   L length;
  59   static jArray<T, L> newJArray(L const len) {
  60     MOZ_ASSERT(len >= 0, "Negative length.");
  61     jArray<T, L> newArray = {new T[size_t(len)], len};
  62     return newArray;
  63   }
  64   static jArray<T, L> newFallibleJArray(L const len) {
  65     MOZ_ASSERT(len >= 0, "Negative length.");
  66     T* a = new (mozilla::fallible) T[size_t(len)];
  67     jArray<T, L> newArray = {a, a ? len : 0};
  68     return newArray;
  69   }
  70   operator T*() { return arr; }
  71   T& operator[](L const index) {
  72     MOZ_ASSERT(index >= 0, "Array access with negative index.");
  73     MOZ_ASSERT(index < length, "Array index out of bounds.");
  74     return arr[index];
  75   }
  76   void operator=(staticJArray<T, L>& other) {
  77     arr = (T*)other.arr;
  78     length = other.length;
  79   }
  80   MOZ_IMPLICIT jArray(decltype(nullptr)) : arr(nullptr), length(0) {}
  81   jArray() : arr(nullptr), length(0) {}
  82
  83  private:
  84   jArray(T* aArr, L aLength) : arr(aArr), length(aLength) {}
  85 };
  86
  87 template <class T, class L>
  88 class autoJArray {
  89  private:
  90   T* arr;
  91
  92  public:
  93   L length;
  94   autoJArray() : arr(0), length(0) {}
  95   MOZ_IMPLICIT autoJArray(const jArray<T, L>& other)
  96       : arr(other.arr), length(other.length) {}
  97   ~autoJArray() { delete[] arr; }
  98   operator T*() { return arr; }
  99   T& operator[](L const index) {
 100     MOZ_ASSERT(index >= 0, "Array access with negative index.");
 101     MOZ_ASSERT(index < length, "Array index out of bounds.");
 102     return arr[index];
 103   }
 104   operator jArray<T, L>() {
 105     // WARNING! This makes it possible to goof with buffer ownership!
 106     // This is needed for the getStack and getListOfActiveFormattingElements
 107     // methods to work sensibly.
 108     jArray<T, L> newArray = {arr, length};
 109     return newArray;
 110   }
 111   void operator=(const jArray<T, L>& other) {
 112     delete[] arr;
 113     arr = other.arr;
 114     length = other.length;
 115   }
 116   void operator=(decltype(nullptr)) {
 117     // Make assigning null to an array in Java delete the buffer in C++
 118     delete[] arr;
 119     arr = nullptr;
 120     length = 0;
 121   }
 122 };
 123
 124 template <class T, size_t S>
 125 class jInlineArray : public std::array<T, S> {
 126  public:
 127   using std::array<T, S>::array;
 128
 129   template <typename U>
 130   explicit jInlineArray(U* aData) {
 131     T* data = this->data();
 132     for (size_t i = 0; i < S; ++i) {
 133       data[i] = aData[i];
 134     }
 135   }
 136 };
 137
 138 #endif  // jArray_h