@Override
  public MappeableContainer andNot(final MappeableRunContainer x) {
    int writeLocation = 0;
    int runStart, runEnd; // the current or upcoming run.
    int whichRun;
    if (x.nbrruns == 0) return clone();

    ShortBuffer buffer = ShortBuffer.allocate(cardinality);

    runStart = BufferUtil.toIntUnsigned(x.getValue(0));
    runEnd = runStart + BufferUtil.toIntUnsigned(x.getLength(0));
    whichRun = 0;

    short val;
    for (int i = 0; i < cardinality; ++i) {
      val = content.get(i);
      int valInt = BufferUtil.toIntUnsigned(val);
      if (valInt < runStart) {
        buffer.put(writeLocation++, val);
      } else if (valInt <= runEnd) ; // don't want item
      else {
        // greater than this run, need to do an advanceUntil on runs
        // done sequentially for now (no galloping attempts).
        do {
          if (whichRun + 1 < x.nbrruns) {
            whichRun++;
            runStart = BufferUtil.toIntUnsigned(x.getValue(whichRun));
            runEnd = runStart + BufferUtil.toIntUnsigned(x.getLength(whichRun));
          } else runStart = runEnd = (1 << 16) + 1; // infinity....
        } while (valInt > runEnd);
        --i; // need to re-process this val
      }
    }
    return new MappeableArrayContainer(writeLocation, buffer);
  }
  @Override
  public MappeableArrayContainer and(final MappeableArrayContainer value2) {

    MappeableArrayContainer value1 = this;
    final int desiredCapacity = Math.min(value1.getCardinality(), value2.getCardinality());
    MappeableArrayContainer answer = new MappeableArrayContainer(desiredCapacity);
    if (BufferUtil.isBackedBySimpleArray(this.content)
        && BufferUtil.isBackedBySimpleArray(value2.content))
      answer.cardinality =
          org.roaringbitmap.Util.unsignedIntersect2by2(
              value1.content.array(),
              value1.getCardinality(),
              value2.content.array(),
              value2.getCardinality(),
              answer.content.array());
    else
      answer.cardinality =
          BufferUtil.unsignedIntersect2by2(
              value1.content,
              value1.getCardinality(),
              value2.content,
              value2.getCardinality(),
              answer.content.array());
    return answer;
  }
  /**
   * it must return items in (unsigned) sorted order. Possible candidate for Container interface? *
   */
  private MappeableContainer or(ShortIterator it, boolean exclusive) {
    MappeableArrayContainer ac = new MappeableArrayContainer();
    int myItPos = 0;
    ac.cardinality = 0;
    // do a merge.  int -1 denotes end of input.
    int myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++));
    int hisHead = advance(it);

    while (myHead != -1 && hisHead != -1) {
      if (myHead < hisHead) {
        ac.emit((short) myHead);
        myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++));
      } else if (myHead > hisHead) {
        ac.emit((short) hisHead);
        hisHead = advance(it);
      } else {
        if (!exclusive) ac.emit((short) hisHead);
        hisHead = advance(it);
        myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++));
      }
    }

    while (myHead != -1) {
      ac.emit((short) myHead);
      myHead = (myItPos == cardinality) ? -1 : BufferUtil.toIntUnsigned(content.get(myItPos++));
    }

    while (hisHead != -1) {
      ac.emit((short) hisHead);
      hisHead = advance(it);
    }

    if (ac.cardinality > DEFAULT_MAX_SIZE) return ac.toBitmapContainer();
    else return ac;
  }
 @Override
 public MappeableContainer or(final MappeableArrayContainer value2) {
   final MappeableArrayContainer value1 = this;
   final int totalCardinality = value1.getCardinality() + value2.getCardinality();
   if (totalCardinality > DEFAULT_MAX_SIZE) { // it could be a bitmap!
     final MappeableBitmapContainer bc = new MappeableBitmapContainer();
     if (!BufferUtil.isBackedBySimpleArray(bc.bitmap))
       throw new RuntimeException("Should not happen. Internal bug.");
     long[] bitArray = bc.bitmap.array();
     if (BufferUtil.isBackedBySimpleArray(value2.content)) {
       short[] sarray = value2.content.array();
       for (int k = 0; k < value2.cardinality; ++k) {
         final int i = BufferUtil.toIntUnsigned(sarray[k]) >>> 6;
         bitArray[i] |= (1l << sarray[k]);
       }
     } else
       for (int k = 0; k < value2.cardinality; ++k) {
         short v2 = value2.content.get(k);
         final int i = BufferUtil.toIntUnsigned(v2) >>> 6;
         bitArray[i] |= (1l << v2);
       }
     if (BufferUtil.isBackedBySimpleArray(this.content)) {
       short[] sarray = this.content.array();
       for (int k = 0; k < this.cardinality; ++k) {
         final int i = BufferUtil.toIntUnsigned(sarray[k]) >>> 6;
         bitArray[i] |= (1l << sarray[k]);
       }
     } else
       for (int k = 0; k < this.cardinality; ++k) {
         final int i = BufferUtil.toIntUnsigned(this.content.get(k)) >>> 6;
         bitArray[i] |= (1l << this.content.get(k));
       }
     bc.cardinality = 0;
     int len = bc.bitmap.limit();
     for (int index = 0; index < len; ++index) {
       bc.cardinality += Long.bitCount(bitArray[index]);
     }
     if (bc.cardinality <= DEFAULT_MAX_SIZE) return bc.toArrayContainer();
     return bc;
   }
   final MappeableArrayContainer answer = new MappeableArrayContainer(totalCardinality);
   if (BufferUtil.isBackedBySimpleArray(value1.content)
       && BufferUtil.isBackedBySimpleArray(value2.content))
     answer.cardinality =
         org.roaringbitmap.Util.unsignedUnion2by2(
             value1.content.array(),
             value1.getCardinality(),
             value2.content.array(),
             value2.getCardinality(),
             answer.content.array());
   else
     answer.cardinality =
         BufferUtil.unsignedUnion2by2(
             value1.content,
             value1.getCardinality(),
             value2.content,
             value2.getCardinality(),
             answer.content.array());
   return answer;
 }
 @Override
 public MappeableContainer iadd(int begin, int end) {
   int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) begin);
   if (indexstart < 0) indexstart = -indexstart - 1;
   int indexend = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (end - 1));
   if (indexend < 0) indexend = -indexend - 1;
   else indexend++;
   int rangelength = end - begin;
   int newcardinality = indexstart + (cardinality - indexend) + rangelength;
   if (newcardinality > DEFAULT_MAX_SIZE) {
     MappeableBitmapContainer a = this.toBitmapContainer();
     return a.iadd(begin, end);
   }
   if (newcardinality >= this.content.limit()) increaseCapacity(newcardinality);
   BufferUtil.arraycopy(
       content, indexend, content, indexstart + rangelength, cardinality - indexend);
   if (BufferUtil.isBackedBySimpleArray(content)) {
     short[] contentarray = content.array();
     for (int k = 0; k < rangelength; ++k) {
       contentarray[k + indexstart] = (short) (begin + k);
     }
   } else {
     for (int k = 0; k < rangelength; ++k) {
       content.put(k + indexstart, (short) (begin + k));
     }
   }
   cardinality = newcardinality;
   return this;
 }
  @Override
  int numberOfRuns() {
    if (cardinality == 0) return 0; // should never happen

    if (BufferUtil.isBackedBySimpleArray(content)) {
      short[] c = content.array();
      int numRuns = 1;
      for (int i = 0; i < cardinality - 1; i++) {
        // this way of doing the computation maximizes superscalar opportunities, can even
        // vectorize!
        if (BufferUtil.toIntUnsigned(c[i]) + 1 != BufferUtil.toIntUnsigned(c[i + 1])) ++numRuns;
      }
      return numRuns;
    } else {
      int numRuns = 0;
      int previous = -2;
      // we do not proceed like above for fear that calling "get" twice per loop would be too much
      for (int i = 0; i < cardinality; i++) {
        int val = BufferUtil.toIntUnsigned(content.get(i));
        if (val != previous + 1) ++numRuns;
        previous = val;
      }
      return numRuns;
    }
  }
  @Override
  public MappeableContainer add(int begin, int end) {

    int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) begin);
    if (indexstart < 0) indexstart = -indexstart - 1;
    int indexend = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (end - 1));
    if (indexend < 0) indexend = -indexend - 1;
    else indexend++;
    int rangelength = end - begin;
    int newcardinality = indexstart + (cardinality - indexend) + rangelength;
    if (newcardinality > DEFAULT_MAX_SIZE) {
      MappeableBitmapContainer a = this.toBitmapContainer();
      return a.iadd(begin, end);
    }
    MappeableArrayContainer answer = new MappeableArrayContainer(newcardinality, content);
    if (!BufferUtil.isBackedBySimpleArray(answer.content))
      throw new RuntimeException("Should not happen. Internal bug.");
    BufferUtil.arraycopy(
        content, indexend, answer.content, indexstart + rangelength, cardinality - indexend);
    short[] answerarray = answer.content.array();
    for (int k = 0; k < rangelength; ++k) {
      answerarray[k + indexstart] = (short) (begin + k);
    }
    answer.cardinality = newcardinality;
    return answer;
  }
  @Override
  public MappeableContainer flip(short x) {
    if (BufferUtil.isBackedBySimpleArray(this.content)) {
      short[] sarray = content.array();
      int loc = Util.unsignedBinarySearch(sarray, 0, cardinality, x);
      if (loc < 0) {
        // Transform the ArrayContainer to a BitmapContainer
        // when cardinality = DEFAULT_MAX_SIZE
        if (cardinality >= DEFAULT_MAX_SIZE) {
          MappeableBitmapContainer a = this.toBitmapContainer();
          a.add(x);
          return a;
        }
        if (cardinality >= sarray.length) {
          increaseCapacity();
          sarray = content.array();
        }
        // insertion : shift the elements > x by one position to
        // the right
        // and put x in it's appropriate place
        System.arraycopy(sarray, -loc - 1, sarray, -loc, cardinality + loc + 1);
        sarray[-loc - 1] = x;
        ++cardinality;
      } else {
        System.arraycopy(sarray, loc + 1, sarray, loc, cardinality - loc - 1);
        --cardinality;
      }
      return this;

    } else {
      int loc = BufferUtil.unsignedBinarySearch(content, 0, cardinality, x);
      if (loc < 0) {
        // Transform the ArrayContainer to a BitmapContainer
        // when cardinality = DEFAULT_MAX_SIZE
        if (cardinality >= DEFAULT_MAX_SIZE) {
          MappeableBitmapContainer a = this.toBitmapContainer();
          a.add(x);
          return a;
        }
        if (cardinality >= content.limit()) {
          increaseCapacity();
        }
        // insertion : shift the elements > x by one position to
        // the right
        // and put x in it's appropriate place
        for (int k = cardinality; k > -loc - 1; --k) content.put(k, content.get(k - 1));
        content.put(-loc - 1, x);
        ++cardinality;
      } else {
        for (int k = loc + 1; k < cardinality; --k) {
          content.put(k - 1, content.get(k));
        }
        --cardinality;
      }
      return this;
    }
  }
  @Override
  public void fillLeastSignificant16bits(int[] x, int i, int mask) {
    if (BufferUtil.isBackedBySimpleArray(this.content)) {
      short[] c = this.content.array();
      for (int k = 0; k < this.cardinality; ++k) x[k + i] = BufferUtil.toIntUnsigned(c[k]) | mask;

    } else
      for (int k = 0; k < this.cardinality; ++k)
        x[k + i] = BufferUtil.toIntUnsigned(this.content.get(k)) | mask;
  }
  // shares lots of code with inot; candidate for refactoring
  @Override
  public MappeableContainer not(final int firstOfRange, final int lastOfRange) {
    // TODO: this can be optimized for performance
    if (firstOfRange >= lastOfRange) {
      return clone(); // empty range
    }

    // determine the span of array indices to be affected
    int startIndex = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) firstOfRange);
    if (startIndex < 0) startIndex = -startIndex - 1;
    int lastIndex =
        BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (lastOfRange - 1));
    if (lastIndex < 0) lastIndex = -lastIndex - 2;
    final int currentValuesInRange = lastIndex - startIndex + 1;
    final int spanToBeFlipped = lastOfRange - firstOfRange;
    final int newValuesInRange = spanToBeFlipped - currentValuesInRange;
    final int cardinalityChange = newValuesInRange - currentValuesInRange;
    final int newCardinality = cardinality + cardinalityChange;

    if (newCardinality > DEFAULT_MAX_SIZE)
      return toBitmapContainer().not(firstOfRange, lastOfRange);

    final MappeableArrayContainer answer = new MappeableArrayContainer(newCardinality);
    if (!BufferUtil.isBackedBySimpleArray(answer.content))
      throw new RuntimeException("Should not happen. Internal bug.");
    short[] sarray = answer.content.array();

    for (int i = 0; i < startIndex; ++i)
      // copy stuff before the active area
      sarray[i] = content.get(i);

    int outPos = startIndex;
    int inPos = startIndex; // item at inPos always >= valInRange

    int valInRange = firstOfRange;
    for (; valInRange < lastOfRange && inPos <= lastIndex; ++valInRange) {
      if ((short) valInRange != content.get(inPos)) sarray[outPos++] = (short) valInRange;
      else {
        ++inPos;
      }
    }

    for (; valInRange < lastOfRange; ++valInRange) {
      answer.content.put(outPos++, (short) valInRange);
    }

    // content after the active range
    for (int i = lastIndex + 1; i < cardinality; ++i) answer.content.put(outPos++, content.get(i));
    answer.cardinality = newCardinality;
    return answer;
  }
 @Override
 public MappeableArrayContainer iand(final MappeableArrayContainer value2) {
   final MappeableArrayContainer value1 = this;
   if (!BufferUtil.isBackedBySimpleArray(value1.content))
     throw new RuntimeException("Should not happen. Internal bug.");
   value1.cardinality =
       BufferUtil.unsignedIntersect2by2(
           value1.content,
           value1.getCardinality(),
           value2.content,
           value2.getCardinality(),
           value1.content.array());
   return this;
 }
 @Override
 public MappeableContainer iremove(int begin, int end) {
   int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) begin);
   if (indexstart < 0) indexstart = -indexstart - 1;
   int indexend = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (end - 1));
   if (indexend < 0) indexend = -indexend - 1;
   else indexend++;
   int rangelength = indexend - indexstart;
   BufferUtil.arraycopy(
       content,
       indexstart + rangelength,
       content,
       indexstart,
       cardinality - indexstart - rangelength);
   cardinality -= rangelength;
   return this;
 }
 @Override
 public MappeableContainer remove(int begin, int end) {
   int indexstart = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) begin);
   if (indexstart < 0) indexstart = -indexstart - 1;
   int indexend = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (end - 1));
   if (indexend < 0) indexend = -indexend - 1;
   else indexend++;
   int rangelength = indexend - indexstart;
   MappeableArrayContainer answer = clone();
   BufferUtil.arraycopy(
       content,
       indexstart + rangelength,
       answer.content,
       indexstart,
       cardinality - indexstart - rangelength);
   answer.cardinality = cardinality - rangelength;
   return answer;
 }
 @Override
 public int rank(short lowbits) {
   int answer = BufferUtil.unsignedBinarySearch(content, 0, cardinality, lowbits);
   if (answer >= 0) {
     return answer + 1;
   } else {
     return -answer - 1;
   }
 }
 @Override
 public MappeableArrayContainer iandNot(MappeableBitmapContainer value2) {
   if (!BufferUtil.isBackedBySimpleArray(this.content))
     throw new RuntimeException("Should not happen. Internal bug.");
   short[] c = this.content.array();
   int pos = 0;
   for (int k = 0; k < cardinality; ++k) if (!value2.contains(c[k])) c[pos++] = c[k];
   this.cardinality = pos;
   return this;
 }
  @Override
  public MappeableContainer inot(final int firstOfRange, final int lastOfRange) {
    // TODO: this can be optimized for performance
    // determine the span of array indices to be affected
    int startIndex = BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) firstOfRange);
    if (startIndex < 0) startIndex = -startIndex - 1;
    int lastIndex =
        BufferUtil.unsignedBinarySearch(content, 0, cardinality, (short) (lastOfRange - 1));
    if (lastIndex < 0) lastIndex = -lastIndex - 1 - 1;
    final int currentValuesInRange = lastIndex - startIndex + 1;
    final int spanToBeFlipped = lastOfRange - firstOfRange;
    final int newValuesInRange = spanToBeFlipped - currentValuesInRange;
    final ShortBuffer buffer = ShortBuffer.allocate(newValuesInRange);
    final int cardinalityChange = newValuesInRange - currentValuesInRange;
    final int newCardinality = cardinality + cardinalityChange;

    if (cardinalityChange > 0) { // expansion, right shifting needed
      if (newCardinality > content.limit()) {
        // so big we need a bitmap?
        if (newCardinality > DEFAULT_MAX_SIZE)
          return toBitmapContainer().inot(firstOfRange, lastOfRange);
        final ShortBuffer co = ShortBuffer.allocate(newCardinality);
        content.rewind();
        co.put(content);
        content = co;
      }
      // slide right the contents after the range
      for (int pos = cardinality - 1; pos > lastIndex; --pos)
        content.put(pos + cardinalityChange, content.get(pos));
      negateRange(buffer, startIndex, lastIndex, firstOfRange, lastOfRange);
    } else { // no expansion needed
      negateRange(buffer, startIndex, lastIndex, firstOfRange, lastOfRange);
      if (cardinalityChange < 0) // contraction, left sliding.
        // Leave array oversize
        for (int i = startIndex + newValuesInRange; i < newCardinality; ++i)
          content.put(i, content.get(i - cardinalityChange));
    }
    cardinality = newCardinality;
    return this;
  }
 @Override
 public void trim() {
   if (this.content.limit() == this.cardinality) return;
   if (BufferUtil.isBackedBySimpleArray(content)) {
     this.content = ShortBuffer.wrap(Arrays.copyOf(content.array(), cardinality));
   } else {
     final ShortBuffer co = ShortBuffer.allocate(this.cardinality);
     // can assume that new co is array backed
     short[] x = co.array();
     for (int k = 0; k < this.cardinality; ++k) x[k] = this.content.get(k);
     this.content = co;
   }
 }
 @Override
 public MappeableContainer remove(final short x) {
   if (BufferUtil.isBackedBySimpleArray(this.content)) {
     final int loc = Util.unsignedBinarySearch(content.array(), 0, cardinality, x);
     if (loc >= 0) {
       // insertion
       System.arraycopy(content.array(), loc + 1, content.array(), loc, cardinality - loc - 1);
       --cardinality;
     }
     return this;
   } else {
     final int loc = BufferUtil.unsignedBinarySearch(content, 0, cardinality, x);
     if (loc >= 0) {
       // insertion
       for (int k = loc + 1; k < cardinality; --k) {
         content.put(k - 1, content.get(k));
       }
       --cardinality;
     }
     return this;
   }
 }
  @Override
  public boolean equals(Object o) {
    if (o instanceof MappeableArrayContainer) {
      final MappeableArrayContainer srb = (MappeableArrayContainer) o;
      if (srb.cardinality != this.cardinality) return false;
      if (BufferUtil.isBackedBySimpleArray(this.content)
          && BufferUtil.isBackedBySimpleArray(srb.content)) {
        short[] t = this.content.array();
        short[] sr = srb.content.array();

        for (int i = 0; i < this.cardinality; ++i) {
          if (t[i] != sr[i]) return false;
        }

      } else
        for (int i = 0; i < this.cardinality; ++i) {
          if (this.content.get(i) != srb.content.get(i)) return false;
        }
      return true;
    } else if (o instanceof MappeableRunContainer) return o.equals(this);
    return false;
  }
 @Override
 protected void writeArray(DataOutput out) throws IOException {
   // little endian
   if (BufferUtil.isBackedBySimpleArray(content)) {
     short[] a = content.array();
     for (int k = 0; k < this.cardinality; ++k) {
       out.writeShort(Short.reverseBytes(a[k]));
     }
   } else {
     for (int k = 0; k < this.cardinality; ++k) {
       out.writeShort(Short.reverseBytes(content.get(k)));
     }
   }
 }
  @Override
  public MappeableArrayContainer iandNot(final MappeableArrayContainer value2) {
    if (!BufferUtil.isBackedBySimpleArray(this.content))
      throw new RuntimeException("Should not happen. Internal bug.");
    if (BufferUtil.isBackedBySimpleArray(value2.content))
      this.cardinality =
          org.roaringbitmap.Util.unsignedDifference(
              this.content.array(),
              this.getCardinality(),
              value2.content.array(),
              value2.getCardinality(),
              this.content.array());
    else
      this.cardinality =
          BufferUtil.unsignedDifference(
              this.content,
              this.getCardinality(),
              value2.content,
              value2.getCardinality(),
              this.content.array());

    return this;
  }
 @Override
 public void writeExternal(ObjectOutput out) throws IOException {
   out.write(this.cardinality & 0xFF);
   out.write((this.cardinality >>> 8) & 0xFF);
   if (BufferUtil.isBackedBySimpleArray(content)) {
     short[] a = content.array();
     for (int k = 0; k < this.cardinality; ++k) {
       out.writeShort(Short.reverseBytes(a[k]));
     }
   } else {
     for (int k = 0; k < this.cardinality; ++k) {
       out.writeShort(Short.reverseBytes(content.get(k)));
     }
   }
 }
  @Override
  public MappeableArrayContainer andNot(MappeableBitmapContainer value2) {

    final MappeableArrayContainer answer = new MappeableArrayContainer(content.limit());
    int pos = 0;
    short[] sarray = answer.content.array();
    if (BufferUtil.isBackedBySimpleArray(this.content)) {
      short[] c = content.array();
      for (int k = 0; k < cardinality; ++k) if (!value2.contains(c[k])) sarray[pos++] = c[k];
    } else
      for (int k = 0; k < cardinality; ++k) {
        short v = this.content.get(k);
        if (!value2.contains(v)) sarray[pos++] = v;
      }
    answer.cardinality = pos;
    return answer;
  }
示例#24
0
  /**
   * Reads an image from an archived file and return it as ByteBuffer object.
   *
   * @author Mike Butler, Kiet Le
   */
  private ByteBuffer readImage(String filename, Dimension dim) {
    if (dim == null) dim = new Dimension(0, 0);
    ByteBuffer bytes = null;
    try {
      DataInputStream dis =
          new DataInputStream(getClass().getClassLoader().getResourceAsStream(filename));
      dim.width = dis.readInt();
      dim.height = dis.readInt();
      System.out.println("Creating buffer, width: " + dim.width + " height: " + dim.height);
      // byte[] buf = new byte[3 * dim.height * dim.width];
      bytes = BufferUtil.newByteBuffer(3 * dim.width * dim.height);
      for (int i = 0; i < bytes.capacity(); i++) {
        bytes.put(dis.readByte());
      }
      dis.close();

    } catch (Exception e) {
      e.printStackTrace();
    }
    bytes.rewind();
    return bytes;
  }
 @Override
 public void advanceIfNeeded(short minval) {
   pos = BufferUtil.advanceUntil(parent.content, pos - 1, parent.cardinality, minval);
 }
 @Override
 public int nextAsInt() {
   return BufferUtil.toIntUnsigned(parent.content.get(pos--));
 }
 private int advance(ShortIterator it) {
   if (it.hasNext()) return BufferUtil.toIntUnsigned(it.next());
   else return -1;
 }
 @Override
 public int nextAsInt() {
   return BufferUtil.toIntUnsigned(content[pos--]);
 }
 protected void loadData(final MappeableBitmapContainer bitmapContainer) {
   this.cardinality = bitmapContainer.cardinality;
   if (!BufferUtil.isBackedBySimpleArray(this.content))
     throw new RuntimeException("Should not happen. Internal bug.");
   bitmapContainer.fillArray(content.array());
 }
 @Override
 public boolean contains(final short x) {
   return BufferUtil.unsignedBinarySearch(content, 0, cardinality, x) >= 0;
 }