lucene3.0.3의 디지털 인덱스 및 디지털 범위 조회

/**            shift，    precisionStep    */
@Override
public boolean incrementToken() {
	
	if (valSize == 0)
		throw new IllegalStateException("call set???Value() before usage");
	if (shift >= valSize)
		return false;
	clearAttributes();
	final char[] buffer;
	switch (valSize) {
		case 64:
			buffer = termAtt.resizeTermBuffer(NumericUtils.BUF_SIZE_LONG);
			//        ，         buffer 
                        //              ，   buffer ，           ，                     
			termAtt.setTermLength(NumericUtils.longToPrefixCoded(value, shift, buffer));
			break;
		case 32:
			buffer = termAtt.resizeTermBuffer(NumericUtils.BUF_SIZE_INT);
			termAtt.setTermLength(NumericUtils.intToPrefixCoded((int) value, shift, buffer));
			break;
		default:
			// should not happen
			throw new IllegalArgumentException("valSize must be 32 or 64");
	}
	typeAtt.setType((shift == 0) ? TOKEN_TYPE_FULL_PREC : TOKEN_TYPE_LOWER_PREC);
	posIncrAtt.setPositionIncrement((shift == 0) ? 1 : 0);//             ，     0        ，       0
	shift += precisionStep;//     
	return true;
	
}

public static int longToPrefixCoded(final long val, final int shift, final char[] buffer) {
		
	if (shift > 63 || shift < 0) 
		throw new IllegalArgumentException("Illegal shift value, must be 0..63");
	
	//                 char   ，       64-       （   shift）    7，      7 bit       ，（63-shift）/7 + 1       。
	int nChars = (63 - shift) / 7 + 1;
	
	//                           char    ，                      ，    32+shift  ，      。
	int len = nChars + 1;
	//        ——     ， 32+shift                ，               ，          （                ，         0），                  ，    （   ）             （  bx    ax  ）
	buffer[0] = (char) (SHIFT_START_LONG + shift);
		
	//0x8000000000000000L      64  1，    0。             ，               1，        0。       ，            ，          ，       。（      ，        ）
	long sortableBits = val ^ 0x8000000000000000L;
	sortableBits >>>= shift; //     shift   ，         。
	while (nChars >= 1) { //  ， 7     ，      7             ，           utf-8  ，7      127， 127   utf8                ，       。
		// Store 7 bits per character for good efficiency when UTF-8 encoding.
		// The whole number is right-justified so that lucene can
		// prefix-encode the terms more efficiently.  。
		//      7 bit，    char。    7 bit    char，   buffer 
		buffer[nChars--] = (char) (sortableBits & 0x7f);
		sortableBits >>>= 7;//       7 
	}
	return len;
} 

//                  
NumericUtils.splitLongRange(new NumericUtils.LongRangeBuilder() {
	@Override
	public final void addRange(String minPrefixCoded, String maxPrefixCoded) {
		rangeBounds.add(minPrefixCoded);
		rangeBounds.add(maxPrefixCoded);
	}
}, precisionStep, minBound, maxBound);

/**                  */
private static void splitRange(final Object builder, final int valSize, final int precisionStep, long minBound,//  
		long maxBound/*  */) {
	if (precisionStep < 1)
		throw new IllegalArgumentException("precisionStep must be >=1");
	if (minBound > maxBound)
		return;
	for (int shift = 0;; shift += precisionStep) {
		
		// calculate new bounds for inner precision 
		final long diff = 1L << (shift + precisionStep); 
		final long mask = ((1L << precisionStep) - 1L) << shift;//          
			
		// minBound                  ，    0               ，                 。           。
		//    true，             ，      addRange （      1）。 
		final boolean hasLower = (minBound & mask) != 0L;
		//   mask          ，    mask              ，          ，  term     。
		//    true，         ，     addRange （   2）
		final boolean hasUpper = (maxBound & mask) != mask;  
		
		
		//                diff，                     （               ），               
		//         632，precisionStp 1，  632  2    ，     63x，     ，631  630    ，          1，  64x         ，   63x。
		final long nextMinBound = (hasLower ? (minBound + diff) : minBound) & ~mask;//&~mask  shift shift+precisionStep   0.
		
		//         ，         ，       9              ，            ，  maxBound 765，             5，     76x       ，
		//   769  768                    。             ，     75x    。
		final long nextMaxBound = (hasUpper ? (maxBound - diff) : maxBound) & ~mask;
		
		//          ，       
		final boolean lowerWrapped = nextMinBound < minBound;
		final boolean upperWrapped = nextMaxBound > maxBound;
		
		// 1、              
		// 2、                ，          ，     ，      ，                  。
		// 3、4      3、4 
		if (shift + precisionStep >= valSize || nextMinBound > nextMaxBound || lowerWrapped || upperWrapped) {
			// We are in the lowest precision or the next precision is not available.
			addRange(builder, valSize, minBound, maxBound, shift);
			// exit the split recursion loop
			break;
		}
		
		if (hasLower)
                        //         
			addRange(builder, valSize, minBound, minBound | mask, shift);//minBound         ，minBound|mask          ，
		
		if (hasUpper)
                         //         
			addRange(builder, valSize, maxBound & ~mask, maxBound, shift);

		minBound = nextMinBound;
		maxBound = nextMaxBound;
	}
}

/** Increments the enumeration to the next element. True if one exists. */
@Override
public boolean next() throws IOException {
	
        //                termEnum，          termEnum     ？             ？
        //          term   ，       ，                      term              ，       ，        term   ，
        //           （    3.0  tii  ），      while    termEnum   ，             term。
	// if a current term exists, the actual enum is initialized:
	// try change to next term, if no such term exists, fall-through
	if (currentTerm != null) {
		assert actualEnum != null;
		if (actualEnum.next()) {
			currentTerm = actualEnum.term();
			if (termCompare(currentTerm))
				return true;
		}
	}
	
	// if all above fails, we go forward to the next enum, if one is available
	currentTerm = null;
	while (rangeBounds.size() >= 2) {//         ，          addRange
		
		assert rangeBounds.size() % 2 == 0;
		// close the current enum and read next bounds
		if (actualEnum != null) {
			actualEnum.close();
			actualEnum = null;
		}
		final String lowerBound = rangeBounds.removeFirst();//
		this.currentUpperBound = rangeBounds.removeFirst();
		// create a new enum
		actualEnum = reader.terms(termTemplate.createTerm(lowerBound));
		currentTerm = actualEnum.term();
		if (currentTerm != null && termCompare(currentTerm))
			return true;
		// clear the current term for next iteration
		currentTerm = null;
	}
			
	// no more sub-range enums available
	assert rangeBounds.size() == 0 && currentTerm == null;
	return false;
}