Get the analysis bits for this walker, as defined in the WalkerFactory.
@return One of WalkerFactory#BIT_DESCENDANT, etc.
323584
public int getAnalysisBits()
  {
  	org.apache.xalan.templates.ElemVariable vvar = getElemVariable();
  	if(null != vvar)
  	{
  		XPath xpath = vvar.getSelect();
  		if(null != xpath)
  		{
	  		Expression expr = xpath.getExpression();
	  		if(null != expr && expr instanceof PathComponent)
	  		{
	  			return ((PathComponent)expr).getAnalysisBits();
	  		}
  		}
  	}
    return WalkerFactory.BIT_FILTER;
  }
748187
private static final Object getCurrentUOWCoord() {
        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.entry(TRACE, "getCurrentUOWCoord");
        }

        Object currentUOW = null;
        if (isRunningInWAS()) {
            currentUOW = EmbeddableTransactionManagerFactory.getUOWCurrent().getUOWCoord();
        }

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
            SibTr.exit(TRACE, "getCurrentUOWCoord", currentUOW);
        }
        return currentUOW;
    }
156025
public int getWeight() {
        if (!hasWitnesses())
            return getMessageSize() * 4;
        try (final ByteArrayOutputStream stream = new UnsafeByteArrayOutputStream(length)) {
            bitcoinSerializeToStream(stream, false);
            final int baseSize = stream.size();
            stream.reset();
            bitcoinSerializeToStream(stream, true);
            final int totalSize = stream.size();
            return baseSize * 3 + totalSize;
        } catch (IOException e) {
            throw new RuntimeException(e); // cannot happen
        }
    }
1151657
def each_bit
      return enum_for(:each_bit) unless block_given?
      index = 0
      bitsize = self.bitsize
      @data.each_byte do |byte|
        loop do
          break if index == bitsize
          bit = (byte >> (7 - (index & 7))) & 1
          yield bit
          index += 1
          break if (index & 7) == 0
        end
      end
      return self
    end
1185595
protected int extractNumeral() {
		int val = 0;
		final int topLeft = getTotalGridElements() - gridWidth;
		int shift = 0;

		// -2 because the top and bottom rows have 2 unusable bits (the first and last)
		for(int i = 1; i < gridWidth - 1; i++) {
			final int idx = topLeft + i;
			val |= classified[idx] << shift;
			//System.out.println("val |= classified[" + idx + "] << " + shift + ";");
			shift++;
		}

		// Don't do the first or last row, handled above and below - special cases
		for(int ii = 1; ii < gridWidth - 1; ii++) {
			for(int i = 0; i < gridWidth; i++) {
				final int idx = getTotalGridElements() - (gridWidth * (ii + 1)) + i;
				val |= classified[idx] << shift;
				//  System.out.println("val |= classified[" + idx + "] << " + shift + ";");
				shift++;
			}
		}

		// The last row
		for(int i = 1; i < gridWidth - 1; i++) {
			val |= classified[i] << shift;
			//System.out.println("val |= classified[" + i + "] << " + shift + ";");
			shift++;
		}

		return val;
	}
1342104
def bit_file

      #Determine ISE's working directory.
      working_directory = get_property(WorkingDirectoryProperty)

      #Find an absolute path at which the most recently generated bit file should reside.
      name = get_property(OutputNameProperty)
      name = File.expand_path("#{working_directory}/#{name}.bit", @base_path)

      #If it exists, return it.
      File::exists?(name) ? name : nil

    end
872132
@Override
	public BitVector bitVector() {
		final LongArrayBitVector result = LongArrayBitVector.ofLength(n);
		for(long i = length; i-- != 0;) result.set(select(i));
		return result;
	}

	@Override
	public int hashCode() {
		return System.identityHashCode(this);
	}

	@Override
	public boolean equals(final Object o) {
		return o == this;
	}

	@Override
	public String toString() {
		return getClass().getName() + '@' + Integer.toHexString(hashCode());
	}
}
456286
public Analyzer<Partition<T>> getOrCreateAnalyzer()
   {
      Node node = childNode.getOrCreate("analyzer");
      Analyzer<Partition<T>> analyzer = new AnalyzerImpl<Partition<T>>(this, "analyzer", childNode, node);
      return analyzer;
   }
258396
static public int getAnalysisBitFromAxes(int axis)
    {
      switch (axis) // Generate new traverser
        {
        case Axis.ANCESTOR :
          return BIT_ANCESTOR;
        case Axis.ANCESTORORSELF :
          return BIT_ANCESTOR_OR_SELF;
        case Axis.ATTRIBUTE :
          return BIT_ATTRIBUTE;
        case Axis.CHILD :
          return BIT_CHILD;
        case Axis.DESCENDANT :
          return BIT_DESCENDANT;
        case Axis.DESCENDANTORSELF :
          return BIT_DESCENDANT_OR_SELF;
        case Axis.FOLLOWING :
          return BIT_FOLLOWING;
        case Axis.FOLLOWINGSIBLING :
          return BIT_FOLLOWING_SIBLING;
        case Axis.NAMESPACE :
        case Axis.NAMESPACEDECLS :
          return BIT_NAMESPACE;
        case Axis.PARENT :
          return BIT_PARENT;
        case Axis.PRECEDING :
          return BIT_PRECEDING;
        case Axis.PRECEDINGSIBLING :
          return BIT_PRECEDING_SIBLING;
        case Axis.SELF :
          return BIT_SELF;
        case Axis.ALLFROMNODE :
          return BIT_DESCENDANT_OR_SELF;
          // case Axis.PRECEDINGANDANCESTOR :
        case Axis.DESCENDANTSFROMROOT :
        case Axis.ALL :
        case Axis.DESCENDANTSORSELFFROMROOT :
          return BIT_ANY_DESCENDANT_FROM_ROOT;
        case Axis.ROOT :
          return BIT_ROOT;
        case Axis.FILTEREDLIST :
          return BIT_FILTER;
        default :
          return BIT_FILTER;
      }
    }
207280
public String getPositionSegment()
   {
      HierarchicalProperty position = member.getChild(new QName("DAV:", "position"));
      return position.getChild(0).getChild(new QName("DAV:", "segment")).getValue();
   }
883124
public int hgetbits(int N)
   {
   	 totbit += N;
	 
	 int val = 0;
	 
	 int pos = buf_byte_idx;
	 if (pos+N < BUFSIZE)
	 {
		while (N-- > 0)
		{
			val <<= 1;
			val |= ((buf[pos++]!=0) ? 1 : 0);		 
		}
	}
	 else
	 {	 
		 while (N-- > 0)
		{
			 val <<= 1;			 
			 val |= ((buf[pos]!=0) ? 1 : 0);
			 pos = (pos+1) & BUFSIZE_MASK;
		}		 
	 }	
	 buf_byte_idx = pos;
	 return val;
   }
189111
public CrumbIssuer getCrumbIssuer() {
        Jenkins h = Jenkins.getInstanceOrNull();
        if(h==null)     return null;    // before Jenkins is initialized?
        return h.getCrumbIssuer();
    }
1199910
def get_bits(block_representation, coin_symbol='btc', api_key=None):
    '''
    
    '''
    return get_block_overview(block_representation=block_representation,
            coin_symbol=coin_symbol, txn_limit=1, api_key=api_key)['bits']
1269048
public alluxio.grpc.Bits getGroupBits() {
    alluxio.grpc.Bits result = alluxio.grpc.Bits.valueOf(groupBits_);
    return result == null ? alluxio.grpc.Bits.NONE : result;
  }
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);
	}
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;
    }
855292
public int[] getEnclosingRectangle() {
    int left = width;
    int top = height;
    int right = -1;
    int bottom = -1;

    for (int y = 0; y < height; y++) {
      for (int x32 = 0; x32 < rowSize; x32++) {
        int theBits = bits[y * rowSize + x32];
        if (theBits != 0) {
          if (y < top) {
            top = y;
          }
          if (y > bottom) {
            bottom = y;
          }
          if (x32 * 32 < left) {
            int bit = 0;
            while ((theBits << (31 - bit)) == 0) {
              bit++;
            }
            if ((x32 * 32 + bit) < left) {
              left = x32 * 32 + bit;
            }
          }
          if (x32 * 32 + 31 > right) {
            int bit = 31;
            while ((theBits >>> bit) == 0) {
              bit--;
            }
            if ((x32 * 32 + bit) > right) {
              right = x32 * 32 + bit;
            }
          }
        }
      }
    }

    if (right < left || bottom < top) {
      return null;
    }

    return new int[] {left, top, right - left + 1, bottom - top + 1};
  }