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/Attributes.h"
  27 #include "mozilla/BinarySearch.h"
  28 #include "nsDebug.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) { return ((T*)arr)[index]; }
  36   L binarySearch(T const elem) {
  37     size_t idx;
  38     bool found = mozilla::BinarySearch(arr, 0, length, elem, &idx);
  39     return found ? idx : -1;
  40   }
  41 };
  42
  43 template<class T, class L>
  44 struct jArray {
  45   T* arr;
  46   L length;
  47   static jArray<T,L> newJArray(L const len) {
  48     NS_ASSERTION(len >= 0, "Bad length.");
  49     jArray<T,L> newArray = { new T[len], len };
  50     return newArray;
  51   }
  52   operator T*() { return arr; }
  53   T& operator[] (L const index) { return arr[index]; }
  54   void operator=(staticJArray<T,L>& other) {
  55     arr = (T*)other.arr;
  56     length = other.length;
  57   }
  58 };
  59
  60 template<class T, class L>
  61 class autoJArray {
  62   private:
  63     T* arr;
  64   public:
  65     L length;
  66     autoJArray()
  67      : arr(0)
  68      , length(0)
  69     {
  70     }
  71     MOZ_IMPLICIT autoJArray(const jArray<T,L>& other)
  72      : arr(other.arr)
  73      , length(other.length)
  74     {
  75     }
  76     ~autoJArray()
  77     {
  78       delete[] arr;
  79     }
  80     operator T*() { return arr; }
  81     T& operator[] (L const index) { return arr[index]; }
  82     operator jArray<T,L>() {
  83       // WARNING! This makes it possible to goof with buffer ownership!
  84       // This is needed for the getStack and getListOfActiveFormattingElements
  85       // methods to work sensibly.
  86       jArray<T,L> newArray = { arr, length };
  87       return newArray;
  88     }
  89     void operator=(const jArray<T,L>& other) {
  90       delete[] arr;
  91       arr = other.arr;
  92       length = other.length;
  93     }
  94     void operator=(decltype(nullptr) n) {
  95       // Make assigning null to an array in Java delete the buffer in C++
  96       MOZ_ASSERT(n == nullptr);
  97       delete[] arr;
  98       arr = nullptr;
  99       length = 0;
 100     }
 101 };
 102
 103 #endif // jArray_h