public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
 {
     Bits docsWithField = FieldCache.DEFAULT.GetDocsWithField(((AtomicReader)context.Reader), Field_Renamed);
     if (Negate_Renamed)
     {
         if (docsWithField is Bits_MatchAllBits)
         {
             return null;
         }
         return new FieldCacheDocIdSetAnonymousInnerClassHelper(this, context.AtomicReader.MaxDoc, acceptDocs, docsWithField);
     }
     else
     {
         if (docsWithField is Bits_MatchNoBits)
         {
             return null;
         }
         if (docsWithField is DocIdSet)
         {
             // UweSays: this is always the case for our current impl - but who knows
             // :-)
             return BitsFilteredDocIdSet.Wrap((DocIdSet)docsWithField, acceptDocs);
         }
         return new FieldCacheDocIdSetAnonymousInnerClassHelper2(this, context.AtomicReader.MaxDoc, acceptDocs, docsWithField);
     }
 }

 public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
 {
     FunctionValues vals = source.GetValues(context, readerContext);
     FunctionValues targets = target.GetValues(context, readerContext);
     FunctionValues defaults = (this.defaultVal == null) ? null : defaultVal.GetValues(context, readerContext);
     return new FloatDocValuesAnonymousInnerClassHelper(this, this, vals, targets, defaults);
 }

		public override FunctionValues GetValues(IDictionary context, AtomicReaderContext
			 readerContext)
		{
			IDictionary<string, FunctionValues> valuesCache = (IDictionary<string, FunctionValues>)context["valuesCache"];
			if (valuesCache == null)
			{
				valuesCache = new Dictionary<string, FunctionValues>();
				context = new Hashtable(context);
				context["valuesCache"] = valuesCache;
			}
			FunctionValues[] externalValues = new FunctionValues[expression.variables.Length];
			for (int i = 0; i < variables.Length; ++i)
			{
				string externalName = expression.variables[i];
				FunctionValues values;
				if (!valuesCache.TryGetValue(externalName,out values))
				{
					values = variables[i].GetValues(context, readerContext);
					if (values == null)
					{
						throw new SystemException("Internal error. External (" + externalName + ") does not exist.");
					}
					valuesCache[externalName] = values;
				}
				externalValues[i] = values;
			}
			return new ExpressionFunctionValues(this, expression, externalValues);
		}

        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            Fields fields = readerContext.AtomicReader.Fields;
            Terms terms = fields.Terms(indexedField);

            return new IntDocValuesAnonymousInnerClassHelper(this, this, terms);
        }

 public _VisitorTemplate_55(IntersectsPrefixTreeFilter _enclosing, AtomicReaderContext
                                                                       baseArg1, IBits baseArg2,
                            bool baseArg3)
     : base(_enclosing, baseArg1, baseArg2, baseArg3)
 {
     this._enclosing = _enclosing;
 }

        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            var arr = cache.GetDoubles(readerContext.AtomicReader, field, parser, true);
            var valid = cache.GetDocsWithField(readerContext.AtomicReader, field);
            return new DoubleDocValuesAnonymousInnerClassHelper(this, arr, valid);

        }

        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            FunctionValues ifVals = ifSource.GetValues(context, readerContext);
            FunctionValues trueVals = trueSource.GetValues(context, readerContext);
            FunctionValues falseVals = falseSource.GetValues(context, readerContext);

            return new FunctionValuesAnonymousInnerClassHelper(this, ifVals, trueVals, falseVals);
        }

        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            var valsArr = new FunctionValues[sources.Length];
            for (int i = 0; i < sources.Length; i++)
            {
                valsArr[i] = sources[i].GetValues(context, readerContext);
            }

            return new FloatDocValuesAnonymousInnerClassHelper(this, this, valsArr);
        }

 public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
 {
     if (processingMode == ProcessingMode.PM_FAST_INVALIDATION)
     {
         return FastBits(context.AtomicReader, acceptDocs);
     }
     else
     {
         return CorrectBits(context.AtomicReader, acceptDocs);
     }
 }

        // TODO: this is trappy? perhaps this query instead should make you pass a slow reader yourself?
        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            IndexReader topReader = ReaderUtil.GetTopLevelContext(readerContext).Reader;
            AtomicReader r = SlowCompositeReaderWrapper.Wrap(topReader);
            int off = readerContext.DocBase;

            var sindex = FieldCache.DEFAULT.GetTermsIndex(r, field);
            var end = sindex.ValueCount;

            return new IntDocValuesAnonymousInnerClassHelper(this, this, off, sindex, end);
        }

 public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
 {
     var searcher = (IndexSearcher)context["searcher"];
     TFIDFSimilarity sim = AsTFIDF(searcher.Similarity, field);
     if (sim == null)
     {
         throw new System.NotSupportedException("requires a TFIDFSimilarity (such as DefaultSimilarity)");
     }
     int docfreq = searcher.IndexReader.DocFreq(new Term(indexedField, indexedBytes));
     float idf = sim.Idf(docfreq, searcher.IndexReader.MaxDoc);
     return new ConstDoubleDocValues(idf, this);
 }

 protected DocTermsIndexDocValues(ValueSource vs, AtomicReaderContext context, string field)
 {
     try
     {
         termsIndex = FieldCache.DEFAULT.GetTermsIndex(context.AtomicReader, field);
     }
     catch (Exception e)
     {
         throw new DocTermsIndexException(field, e);
     }
     this.vs = vs;
 }

	    /// <summary>
		/// <code>context</code> must contain a key "scorer" which is a
		/// <see cref="Lucene.Net.Search.Scorer">Lucene.Net.Search.Scorer</see>
		/// .
		/// </summary>
		/// <exception cref="System.IO.IOException"></exception>
		public override FunctionValues GetValues(IDictionary context, AtomicReaderContext
			 readerContext)
		{
			Scorer v = (Scorer)context["scorer"];
		    hashCodeObj = v;
			if (v == null)
			{
				throw new InvalidOperationException("Expressions referencing the score can only be used for sorting"
					);
			}
			return new ScoreFunctionValues(this, v);
		}

        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            var fields = readerContext.AtomicReader.Fields;
            var terms = fields.Terms(indexedField);
            var searcher = (IndexSearcher)context["searcher"];
            var similarity = IDFValueSource.AsTFIDF(searcher.Similarity, indexedField);
            if (similarity == null)
            {
                throw new System.NotSupportedException("requires a TFIDFSimilarity (such as DefaultSimilarity)");
            }

            return new FloatDocValuesAnonymousInnerClassHelper(this, this, terms, similarity);
        }

        public override DocIdSet GetDocIdSet(AtomicReaderContext context, Bits acceptDocs)
        {
            Terms terms = context.AtomicReader.Terms(term.Field());
            if (terms == null)
            {
                return null;
            }

            TermsEnum termsEnum = terms.Iterator(null);
            if (!termsEnum.SeekExact(term.Bytes()))
            {
                return null;
            }
            return new DocIdSetAnonymousInnerClassHelper(this, acceptDocs, termsEnum);
        }

 public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
 {
     FieldInfo fieldInfo = readerContext.AtomicReader.FieldInfos.FieldInfo(field);
     // To be sorted or not to be sorted, that is the question
     // TODO: do it cleaner?
     if (fieldInfo != null && fieldInfo.DocValuesType == FieldInfo.DocValuesType_e.BINARY)
     {
         BinaryDocValues binaryValues = Search.FieldCache.DEFAULT.GetTerms(readerContext.AtomicReader, field, true);
         Bits docsWithField = Search.FieldCache.DEFAULT.GetDocsWithField(readerContext.AtomicReader, field);
         return new FunctionValuesAnonymousInnerClassHelper(this, binaryValues, docsWithField);
     }
     else
     {
         return new DocTermsIndexDocValuesAnonymousInnerClassHelper(this, this, readerContext, field);
     }
 }

        public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
        {
            var searcher = (IndexSearcher)context["searcher"];
            TFIDFSimilarity similarity = IDFValueSource.AsTFIDF(searcher.Similarity, field);
            if (similarity == null)
            {
                throw new System.NotSupportedException("requires a TFIDFSimilarity (such as DefaultSimilarity)");
            }

            NumericDocValues norms = readerContext.AtomicReader.GetNormValues(field);
            if (norms == null)
            {
                return new ConstDoubleDocValues(0.0, this);
            }

            return new FloatDocValuesAnonymousInnerClassHelper(this, this, similarity, norms);
        }

 public CustomScoreProviderAnonymousInnerClassHelper(CustomMulAddQuery outerInstance, AtomicReaderContext context)
     : base(context)
 {
     this.outerInstance = outerInstance;
 }

 public override FunctionValues GetValues(IDictionary context, AtomicReaderContext readerContext)
 {
     var searcher = (IndexSearcher)context["searcher"];
     int docfreq = searcher.IndexReader.DocFreq(new Term(indexedField, indexedBytes));
     return new ConstIntDocValues(docfreq, this);
 }

 protected override CustomScoreProvider GetCustomScoreProvider(AtomicReaderContext context)
 {
     return new CustomScoreProviderAnonymousInnerClassHelper(this, context);
 }