Line data    Source code

       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 "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          69 :   T& operator[] (L const index) {
      36          69 :     MOZ_ASSERT(index >= 0, "Array access with negative index.");
      37          69 :     MOZ_ASSERT(index < length, "Array index out of bounds.");
      38          69 :     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             : struct jArray {
      49             :   T* arr;
      50             :   L length;
      51          45 :   static jArray<T,L> newJArray(L const len) {
      52          45 :     MOZ_ASSERT(len >= 0, "Negative length.");
      53          90 :     jArray<T,L> newArray = { new T[size_t(len)], len };
      54          45 :     return newArray;
      55             :   }
      56           4 :   static jArray<T,L> newFallibleJArray(L const len) {
      57           4 :     MOZ_ASSERT(len >= 0, "Negative length.");
      58           8 :     T* a = new (mozilla::fallible) T[size_t(len)];
      59           4 :     jArray<T,L> newArray = { a, a ? len : 0 };
      60           4 :     return newArray;
      61             :   }
      62          10 :   operator T*() { return arr; }
      63         318 :   T& operator[] (L const index) {
      64         318 :     MOZ_ASSERT(index >= 0, "Array access with negative index.");
      65         318 :     MOZ_ASSERT(index < length, "Array index out of bounds.");
      66         318 :     return arr[index];
      67             :   }
      68          40 :   void operator=(staticJArray<T,L>& other) {
      69          40 :     arr = (T*)other.arr;
      70          40 :     length = other.length;
      71          40 :   }
      72             : };
      73             : 
      74             : template<class T, class L>
      75             : class autoJArray {
      76             :   private:
      77             :     T* arr;
      78             :   public:
      79             :     L length;
      80          24 :     autoJArray()
      81             :      : arr(0)
      82          24 :      , length(0)
      83             :     {
      84          24 :     }
      85          29 :     MOZ_IMPLICIT autoJArray(const jArray<T,L>& other)
      86          29 :      : arr(other.arr)
      87          29 :      , length(other.length)
      88             :     {
      89          29 :     }
      90          26 :     ~autoJArray()
      91             :     {
      92          26 :       delete[] arr;
      93          26 :     }
      94         126 :     operator T*() { return arr; }
      95        1349 :     T& operator[] (L const index) {
      96        1349 :       MOZ_ASSERT(index >= 0, "Array access with negative index.");
      97        1349 :       MOZ_ASSERT(index < length, "Array index out of bounds.");
      98        1349 :       return arr[index];
      99             :     }
     100          30 :     operator jArray<T,L>() {
     101             :       // WARNING! This makes it possible to goof with buffer ownership!
     102             :       // This is needed for the getStack and getListOfActiveFormattingElements
     103             :       // methods to work sensibly.
     104          30 :       jArray<T,L> newArray = { arr, length };
     105          30 :       return newArray;
     106             :     }
     107          20 :     void operator=(const jArray<T,L>& other) {
     108          20 :       delete[] arr;
     109          20 :       arr = other.arr;
     110          20 :       length = other.length;
     111          20 :     }
     112          14 :     void operator=(decltype(nullptr)) {
     113             :       // Make assigning null to an array in Java delete the buffer in C++
     114          14 :       delete[] arr;
     115          14 :       arr = nullptr;
     116          14 :       length = 0;
     117          14 :     }
     118             : };
     119             : 
     120             : #endif // jArray_h