private static boolean actualContain(AtomicReader reader, String field, int locDocId) {
  try {
    // index really contains such field of this doc
    return FieldCache.DEFAULT.getDocsWithField(reader, field).get(locDocId);
  } catch (IOException e) {
    return false;
  }
}
 

private void buildFieldMap( ResponseBuilder rb ) throws IOException {
  Log.debug( "buildFieldMap" );
  SolrIndexSearcher searcher = rb.req.getSearcher();
  // build a synonym map from the SortedDocValues -
  // for each field value: lower case, stemmed, lookup synonyms from synonyms.txt - map to fieldValue
  SynonymMap.Builder fieldBuilder = new SynonymMap.Builder( true );
  SynonymMap.Builder termBuilder = new SynonymMap.Builder( true );
    
  ArrayList<String> searchFields = getStringFields( searcher );

  for (String searchField : searchFields ) {
    Log.debug( "adding searchField " + searchField );
    CharsRef fieldChars = new CharsRef( searchField );
    SortedSetDocValues sdv = FieldCache.DEFAULT.getDocTermOrds( searcher.getAtomicReader( ), searchField );
    if (sdv == null) continue;
    Log.debug( "got SortedSetDocValues for " + searchField );
    TermsEnum te = sdv.termsEnum();
    while (te.next() != null) {
      BytesRef term = te.term();
      String fieldValue = term.utf8ToString( );
      addTerm ( fieldChars, fieldValue, fieldBuilder, termBuilder );
    }
  }
    
  addDistributedTerms( rb, fieldBuilder, termBuilder, searchFields );
    
  fieldMap = fieldBuilder.build( );
  termMap = termBuilder.build( );
}
 

@Override
@SuppressWarnings("rawtypes")
public FunctionValues getValues(Map context, AtomicReaderContext readerContext) throws IOException {
  final BinaryDocValues joinValues = FieldCache.DEFAULT.getTerms(readerContext.reader(), joinField, false);

  return new DoubleDocValues(this) {

    @Override
    public double doubleVal(int doc) {
      BytesRef joinValue = joinValues.get(doc);
      if (joinValue == null) {
        throw new RuntimeException("No such doc: " + doc);
      }
      Object result = results.getResult(joinValue.utf8ToString());
      if (result == null) {
        return defaultValue;
      }
      if (result instanceof Iterable) {
        Double max = null;
        for (Object object : (Iterable)result) {
          if (object != null) {
            double value = getValue(object);
            if (max == null || value > max) {
              max = value;
            }
          }
        }
        return max != null ? max : defaultValue;
      } else {
        return getValue(result);
      }
    }
    
  };
}
 

@Override
public Bits getDocsWithField(AtomicReader reader, String field) throws IOException {
  return FieldCache.DEFAULT.getDocsWithField(reader, field);
}
 

@Override
public Bytes getBytes(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getBytes(reader, field, setDocsWithField);
}
 

@Override
public Bytes getBytes(AtomicReader reader, String field, ByteParser parser, boolean setDocsWithField)
    throws IOException {
  return FieldCache.DEFAULT.getBytes(reader, field, parser, setDocsWithField);
}
 

@Override
public Shorts getShorts(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getShorts(reader, field, setDocsWithField);
}
 

@Override
public Shorts getShorts(AtomicReader reader, String field, ShortParser parser, boolean setDocsWithField)
    throws IOException {
  return FieldCache.DEFAULT.getShorts(reader, field, parser, setDocsWithField);
}
 

@Override
public Ints getInts(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getInts(reader, field, setDocsWithField);
}
 

@Override
public Ints getInts(AtomicReader reader, String field, IntParser parser, boolean setDocsWithField)
    throws IOException {
  return FieldCache.DEFAULT.getInts(reader, field, parser, setDocsWithField);
}
 

@Override
public Floats getFloats(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getFloats(reader, field, setDocsWithField);
}
 

@Override
public Floats getFloats(AtomicReader reader, String field, FloatParser parser, boolean setDocsWithField)
    throws IOException {
  return FieldCache.DEFAULT.getFloats(reader, field, parser, setDocsWithField);
}
 

@Override
public Longs getLongs(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getLongs(reader, field, setDocsWithField);
}
 

@Override
public Longs getLongs(AtomicReader reader, String field, LongParser parser, boolean setDocsWithField)
    throws IOException {
  return FieldCache.DEFAULT.getLongs(reader, field, parser, setDocsWithField);
}
 

@Override
public Doubles getDoubles(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getDoubles(reader, field, setDocsWithField);
}
 

@Override
public Doubles getDoubles(AtomicReader reader, String field, DoubleParser parser, boolean setDocsWithField)
    throws IOException {
  return FieldCache.DEFAULT.getDoubles(reader, field, parser, setDocsWithField);
}
 

@Override
public BinaryDocValues getTerms(AtomicReader reader, String field, boolean setDocsWithField) throws IOException {
  return FieldCache.DEFAULT.getTerms(reader, field, setDocsWithField);
}
 

@Override
public BinaryDocValues getTerms(AtomicReader reader, String field, boolean setDocsWithField,
                                float acceptableOverheadRatio) throws IOException {
  return FieldCache.DEFAULT.getTerms(reader, field, setDocsWithField, acceptableOverheadRatio);
}
 

@Override
public SortedDocValues getTermsIndex(AtomicReader reader, String field) throws IOException {
  return FieldCache.DEFAULT.getTermsIndex(reader, field);
}
 

@Override
public SortedDocValues getTermsIndex(AtomicReader reader, String field, float acceptableOverheadRatio)
    throws IOException {
  return FieldCache.DEFAULT.getTermsIndex(reader, field, acceptableOverheadRatio);
}
 

@Override
public SortedSetDocValues getDocTermOrds(AtomicReader reader, String field) throws IOException {
  return FieldCache.DEFAULT.getDocTermOrds(reader, field);
}
 

public IntsWrapper(String field, AtomicReader reader) throws IOException {
  ints = FieldCache.DEFAULT.getInts(reader, field, false);
}
 

public LongsWrapper(String field, AtomicReader reader) throws IOException {
  longs = FieldCache.DEFAULT.getLongs(reader, field, false);
}
 

public DoublesWrapper(String field, AtomicReader reader) throws IOException {
  doubles = FieldCache.DEFAULT.getDoubles(reader, field, false);
}
 

public FloatsWrapper(String field, AtomicReader reader) throws IOException {
  floats = FieldCache.DEFAULT.getFloats(reader, field, false);
}
 

public IndexedStringsWrapper(String field, AtomicReader reader) throws IOException {
  values = FieldCache.DEFAULT.getTerms(reader, field, false);
}
 

public static Float getFieldFloatValue(List<AtomicReaderContext> leaves, int docId, String fieldName)
    throws IOException {
  AtomicReaderContext atomicReaderContext = leaves.get(ReaderUtil.subIndex(docId, leaves));
  FieldCache.Floats floats = FieldCache.DEFAULT.getFloats(atomicReaderContext.reader(), fieldName, false);
  return floats.get(docId - atomicReaderContext.docBase);
}
 

public static Double getFieldDoubleValue(List<AtomicReaderContext> leaves, int docId, String fieldName)
    throws IOException {
  AtomicReaderContext atomicReaderContext = leaves.get(ReaderUtil.subIndex(docId, leaves));
  FieldCache.Doubles doubles = FieldCache.DEFAULT.getDoubles(atomicReaderContext.reader(), fieldName, false);
  return doubles.get(docId - atomicReaderContext.docBase);
}
 

public static String getFieldStringValue(List<AtomicReaderContext> leaves, int docId, String fieldName)
    throws IOException {
  AtomicReaderContext atomicReaderContext = leaves.get(ReaderUtil.subIndex(docId, leaves));
  BinaryDocValues terms = FieldCache.DEFAULT.getTerms(atomicReaderContext.reader(), fieldName, false);
  return terms.get(docId - atomicReaderContext.docBase).utf8ToString();
}
 

public static Long getFieldLongValue(List<AtomicReaderContext> leaves, int docId, String fieldName)
    throws IOException {
  AtomicReaderContext atomicReaderContext = leaves.get(ReaderUtil.subIndex(docId, leaves));
  FieldCache.Longs longs = FieldCache.DEFAULT.getLongs(atomicReaderContext.reader(), fieldName, false);
  return longs.get(docId - atomicReaderContext.docBase);
}