LCOV - code coverage report
Current view: directory - parser/html - jArray.h (source / functions) Found Hit Coverage
Test: app.info Lines: 45 35 77.8 %
Date: 2012-06-02 Functions: 39 22 56.4 %

       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 "nsDebug.h"
      27                 : 
      28                 : template<class T, class L>
      29                 : struct staticJArray {
      30                 :   const T* arr;
      31                 :   const L length;
      32                 :   operator T*() { return arr; }
      33               0 :   T& operator[] (L const index) { return ((T*)arr)[index]; }
      34             124 :   L binarySearch(T const elem) {
      35             124 :     L lo = 0;
      36             124 :     L hi = length - 1;
      37            1072 :     while (lo <= hi) {
      38             948 :       L mid = (lo + hi) / 2;
      39             948 :       if (arr[mid] > elem) {
      40             598 :         hi = mid - 1;
      41             350 :       } else if (arr[mid] < elem) {
      42             226 :         lo = mid + 1;
      43                 :       } else {
      44             124 :         return mid;
      45                 :       }
      46                 :     }
      47               0 :     return -1;
      48                 :   }
      49                 : };
      50                 : 
      51                 : template<class T, class L>
      52                 : struct jArray {
      53                 :   T* arr;
      54                 :   L length;
      55            4002 :   static jArray<T,L> newJArray(L const len) {
      56            4002 :     NS_ASSERTION(len >= 0, "Bad length.");
      57            8004 :     jArray<T,L> newArray = { new T[len], len };
      58                 :     return newArray;
      59                 :   }
      60               0 :   operator T*() { return arr; }
      61               0 :   T& operator[] (L const index) { return arr[index]; }
      62               0 :   void operator=(staticJArray<T,L>& other) {
      63               0 :     arr = (T*)other.arr;
      64               0 :     length = other.length;
      65               0 :   }
      66                 : };
      67                 : 
      68                 : template<class T, class L>
      69                 : class autoJArray {
      70                 :   private:
      71                 :     T* arr;
      72                 :   public:
      73                 :     L length;
      74              60 :     autoJArray()
      75                 :      : arr(0)
      76              60 :      , length(0)
      77                 :     {
      78              60 :     }
      79            2832 :     autoJArray(const jArray<T,L>& other)
      80                 :      : arr(other.arr)
      81            2832 :      , length(other.length)
      82                 :     {
      83            2832 :     }
      84            2890 :     ~autoJArray()
      85                 :     {
      86            2890 :       delete[] arr;
      87            2890 :     }
      88            1201 :     operator T*() { return arr; }
      89            3594 :     T& operator[] (L const index) { return arr[index]; }
      90               0 :     operator jArray<T,L>() {
      91                 :       // WARNING! This makes it possible to goof with buffer ownership!
      92                 :       // This is needed for the getStack and getListOfActiveFormattingElements
      93                 :       // methods to work sensibly.
      94               0 :       jArray<T,L> newArray = { arr, length };
      95                 :       return newArray;
      96                 :     }
      97            1170 :     void operator=(const jArray<T,L>& other) {
      98            1170 :       delete[] arr;
      99            1170 :       arr = other.arr;
     100            1170 :       length = other.length;
     101            1170 :     }
     102            1170 :     void operator=(L zero) {
     103                 :       // Make assigning null to an array in Java delete the buffer in C++
     104            1170 :       NS_ASSERTION(!zero, "Non-zero integer assigned to jArray.");
     105            1170 :       delete[] arr;
     106            1170 :       arr = 0;
     107            1170 :       length = 0;
     108            1170 :     }
     109                 : };
     110                 : 
     111                 : #endif // jArray_h_

Generated by: LCOV version 1.7