Total number of usable bits stored by this entire list. This sums the
difference of each list element's "usableBits" and "offset".
@return Total valid bits in this list.
177706
public int getTotalBits() {
    //this total calculates and removes the bits reserved for "offset"
    //   between the different children.
    int total = 0;
    EncodedElement iter = this;
    while(iter != null) {
      total += iter.usableBits - iter.offset;
      iter = iter.next;
    }
    return total;
  }
52374
public byte[] getOctets() {
        byte[] octets = new byte[8];
        long bits = this.bits;
        for (int n = 8; --n >= 0; bits >>= 8) {
            octets[n] = (byte) (bits & 0xff);
        }
        return octets;
    }
413122
public long countBits(boolean bit, long position) {
		updateCount();
		int blockNumber = (int) (position / this.blockSize);
		long mark = ((long) blockNumber) * this.blockSize;
		long trueValues = 0;
		if (blockNumber > 0) {
			trueValues = this.countArray[blockNumber - 1];
		}
		for (long index = mark; index <= position; index++) {
			trueValues += this.bitVector.getBit(index) ? 1 : 0;
		}
		return bit ? trueValues : ((position + 1) - trueValues);
	}
883542
public BigDecimal getTotal() {

		BigDecimal total = BigDecimal.ZERO;

		for ( LineItem item : lineItems ) {
			total = total.add( item.getTotal() );
		}

		return total;
	}
877861
public int calcLength() {
        int bits = STREAMINFO_MIN_BLOCK_SIZE_LEN 
                   + STREAMINFO_MAX_BLOCK_SIZE_LEN
                   + STREAMINFO_MIN_FRAME_SIZE_LEN
                   + STREAMINFO_MAX_FRAME_SIZE_LEN
                   + STREAMINFO_SAMPLE_RATE_LEN
                   + STREAMINFO_CHANNELS_LEN
                   + STREAMINFO_BITS_PER_SAMPLE_LEN
                   + STREAMINFO_TOTAL_SAMPLES_LEN
                   + (md5sum.length * 8);
        return ((bits + 7) / 8);
    }
1269048
public alluxio.grpc.Bits getGroupBits() {
    alluxio.grpc.Bits result = alluxio.grpc.Bits.valueOf(groupBits_);
    return result == null ? alluxio.grpc.Bits.NONE : result;
  }
928796
public final int getLiveSegmentCount() {
        int num = 0;

        for (int i = 0; i < _segList.size(); i++) {
            if (_segList.get(i) != null)
                num++;
        }

        return num;
    }
509352
public alluxio.grpc.Bits getOtherBits() {
    alluxio.grpc.Bits result = alluxio.grpc.Bits.valueOf(otherBits_);
    return result == null ? alluxio.grpc.Bits.NONE : result;
  }
730566
public boolean padToByte() {
    boolean padded = false;

    EncodedElement end = EncodedElement.getEnd_S(this);
    int tempVal = end.usableBits;
    if(tempVal % 8 != 0) {
      int toWrite = 8-(tempVal%8);
      end.addInt(0, toWrite);
      /* Assert FOR DEVEL ONLY: */
      assert((this.getTotalBits()+offset) % 8 == 0);
      padded = true;
    }
    return padded;
  }
22047
@Override
	public long getBits(int position, int length) {
		if (position < 0) throw new IllegalArgumentException("negative position");
		int limit = position + length;
		if (limit > size) throw new IllegalArgumentException("length too great");
		// contained in extensions
		if (position >= start || limit < finish) return extensionBits(length);
		// contained in store
		if (position >= finish && limit <= start) return store.getBits(position - finish, length);
		// overlaps extensions and store
		return super.getBits(position, length);
	}
1281571
public int getAnalysisBits()
  {
    if (null != m_expr && m_expr instanceof PathComponent)
    {
      return ((PathComponent) m_expr).getAnalysisBits();
    }
    return WalkerFactory.BIT_FILTER;
  }
1268374
public long getKeyMemoryUsageBytes() {
    long total = 0;
    for (int i = 0; i < maps_.length; i++) {
      if (maps_[i] != null) {
        total += (long) (maps_[i].getActiveEntries()) * keySizeBytes_;
      }
    }
    return total;
  }
286759
public static boolean[] getBits(final byte... bytes) {
        if (bytes.length > 4) {
            throw new InvalidParameterException("Invalid number of bytes");
        }

        final boolean[] res = new boolean[bytes.length * 8];

        int pos = 0;

        for (byte b : bytes) {
            for (boolean bool : getBits(b)) {
                res[pos] = bool;
                pos++;
            }
        }

        return res;
    }
888060
List<Long> getPositionList() {
		List<Long> ret = new ArrayList<Long>();

		ret.add(-1L);
		/*
		 * This -1 is pointing to the previous position of the first valid
		 * position of the bit vector, which starts at index 0. Since the zeroth
		 * occurrence of a bit is undefined, the first occurrence can be at
		 * position 0, or later.
		 */

		long count = 0;
		for (long index = 0; index < this.bitVector.size(); index++) {
			if (this.bitVector.getBit(index) == this.bit) {
				count++;
			}
			if (count >= this.blockSize) {
				count = 0;
				ret.add(index);
			}
		}
		return ret;
	}
538903
public Coin getOutputSum() {
        Coin totalOut = Coin.ZERO;

        for (TransactionOutput output: outputs) {
            totalOut = totalOut.add(output.getValue());
        }

        return totalOut;
    }
752563
public Bits read(final int bits) throws IOException {
    final int additionalBitsNeeded = bits - this.remainder.bitLength;
    final int additionalBytesNeeded = (int) Math.ceil(additionalBitsNeeded / 8.);
    if (additionalBytesNeeded > 0) this.readAhead(additionalBytesNeeded);
    final Bits readBits = this.remainder.range(0, bits);
    this.remainder = this.remainder.range(bits);
    return readBits;
  }
624749
public boolean isSet(int bit) {
    int bite = byteForBit(bit);
    if (bite >= bits.length || bits.length == 0) {
      return false;
    }
    int bitOnByte = bitOnByte(bit, bite);
    return ((1 << bitOnByte) & bits[bite]) != 0;
  }