public override void SetScorer(Scorer scorer)
 {
     foreach (DocComparator comparator in _comparators)
     {
         comparator.SetScorer(scorer);
     }
 }

 protected internal DisjunctionScorer(Weight weight, Scorer[] subScorers)
     : base(weight)
 {
     this.SubScorers = subScorers;
     this.NumScorers = subScorers.Length;
     Heapify();
 }

		public override bool Next()
		{
			if (firstTime)
			{
				if (!exclScorer.Next())
				{
					exclScorer = null; // exhausted at start
				}
				firstTime = false;
			}
			if (reqScorer == null)
			{
				return false;
			}
			if (!reqScorer.Next())
			{
				reqScorer = null; // exhausted, nothing left
				return false;
			}
			if (exclScorer == null)
			{
				return true; // reqScorer.next() already returned true
			}
			return ToNonExcluded();
		}

     public virtual Scorer CreateScorer(Scorer innerScorer, IndexReader reader, bool scoreDocsInOrder, bool topScorer)
     {
         if(!(reader is BoboIndexReader)) 
             throw new ArgumentException("IndexReader is not BoboIndexReader");
 
         return new FacetBasedBoostingScorer(this, (BoboIndexReader)reader, innerScorer.Similarity, innerScorer);
     }

 /// <summary>Construct a <code>ReqExclScorer</code>.</summary>
 /// <param name="reqScorer">The scorer that must match, except where
 /// </param>
 /// <param name="exclScorer">indicates exclusion.
 /// </param>
 public ReqExclScorer(Scorer reqScorer, Scorer exclScorer)
     : base(null)
 {
     // No similarity used.
     this.reqScorer = reqScorer;
     this.exclScorer = exclScorer;
 }

 private AssertingScorer(Random random, Scorer @in)
     : base(@in.Weight)
 {
     this.Random = random;
     [email protected] = @in;
     this.DocsEnumIn = new AssertingAtomicReader.AssertingDocsEnum(@in);
 }

 /// <summary>Construct a <code>ReqExclScorer</code>.</summary>
 /// <param name="reqScorer">The scorer that must match, except where
 /// </param>
 /// <param name="exclDisi">indicates exclusion.
 /// </param>
 public ReqExclScorer(Scorer reqScorer, DocIdSetIterator exclDisi)
     : base(null)
 {
     // No similarity used.
     this.reqScorer = reqScorer;
     this.exclDisi = exclDisi;
 }

 /// <summary>Construct a <code>ReqOptScorer</code>.</summary>
 /// <param name="reqScorer">The required scorer. This must match.
 /// </param>
 /// <param name="optScorer">The optional scorer. This is used for scoring only.
 /// </param>
 public ReqOptSumScorer(Scorer reqScorer, Scorer optScorer)
     : base(null)
 {
     // No similarity used.
     this.reqScorer = reqScorer;
     this.optScorer = optScorer;
 }

 public override void SetScorer(Scorer scorer)
 {
     // Set a ScoreCachingWrappingScorer in case the wrapped Collector will call
     // score() also.
     this.scorer = new ScoreCachingWrappingScorer(scorer);
     c.SetScorer(this.scorer);
 }

		/// <summary>Returns the score of the current document matching the query.
		/// Initially invalid, until {@link #Next()} is called the first time.
		/// </summary>
		/// <returns> The score of the required scorer, eventually increased by the score
		/// of the optional scorer when it also matches the current document.
		/// </returns>
		public override float Score()
		{
			int curDoc = reqScorer.Doc();
			float reqScore = reqScorer.Score();
			if (firstTimeOptScorer)
			{
				firstTimeOptScorer = false;
				if (!optScorer.SkipTo(curDoc))
				{
					optScorer = null;
					return reqScore;
				}
			}
			else if (optScorer == null)
			{
				return reqScore;
			}
			else if ((optScorer.Doc() < curDoc) && (!optScorer.SkipTo(curDoc)))
			{
				optScorer = null;
				return reqScore;
			}
			// assert (optScorer != null) && (optScorer.doc() >= curDoc);
			return (optScorer.Doc() == curDoc)?reqScore + optScorer.Score():reqScore;
		}

 public override void SetScorer(Scorer _scorer)
 {
     this.scorer = _scorer;
     for (int i = 0; i < hitQueue.comparators.Length; i++)
     {
         hitQueue.comparators[i].SetScorer(_scorer);
     }
 }

 /// <summary>
 /// Construct a <code>ReqOptScorer</code>. </summary>
 /// <param name="reqScorer"> The required scorer. this must match. </param>
 /// <param name="optScorer"> The optional scorer. this is used for scoring only. </param>
 public ReqOptSumScorer(Scorer reqScorer, Scorer optScorer)
     : base(reqScorer.weight)
 {
     Debug.Assert(reqScorer != null);
     Debug.Assert(optScorer != null);
     this.ReqScorer = reqScorer;
     this.OptScorer = optScorer;
 }

		/// <summary>Add the scorer for a subquery</summary>
		/// <param name="scorer">the scorer of a subquery of our associated DisjunctionMaxQuery
		/// </param>
		public virtual void  Add(Scorer scorer)
		{
			if (scorer.Next())
			{
				// Initialize and retain only if it produces docs
				subScorers.Add(scorer);
				more = true;
			}
		}

			public SubScorer(Scorer scorer, bool required, bool prohibited, HitCollector collector, SubScorer next)
			{
				this.scorer = scorer;
				this.done = !scorer.Next();
				this.required = required;
				this.prohibited = prohibited;
				this.collector = collector;
				this.next = next;
			}

        public ConjunctionScorer(Similarity similarity, Scorer[] scorers)
            : base(similarity)
        {
            this.scorers = scorers;
            coord = similarity.Coord(scorers.Length, scorers.Length);

            for (int i = 0; i < scorers.Length; i++)
            {
                if (scorers[i].NextDoc() == NO_MORE_DOCS)
                {
                    // If even one of the sub-scorers does not have any documents, this
                    // scorer should not attempt to do any more work.
                    lastDoc = NO_MORE_DOCS;
                    return ;
                }
            }

            // Sort the array the first time...
            // We don't need to sort the array in any future calls because we know
            // it will already start off sorted (all scorers on same doc).

            // note that this comparator is not consistent with equals!
            System.Array.Sort(scorers, new AnonymousClassComparator(this));

            // NOTE: doNext() must be called before the re-sorting of the array later on.
            // The reason is this: assume there are 5 scorers, whose first docs are 1,
            // 2, 3, 5, 5 respectively. Sorting (above) leaves the array as is. Calling
            // doNext() here advances all the first scorers to 5 (or a larger doc ID
            // they all agree on).
            // However, if we re-sort before doNext() is called, the order will be 5, 3,
            // 2, 1, 5 and then doNext() will stop immediately, since the first scorer's
            // docs equals the last one. So the invariant that after calling doNext()
            // all scorers are on the same doc ID is broken.
            if (DoNext() == NO_MORE_DOCS)
            {
                // The scorers did not agree on any document.
                lastDoc = NO_MORE_DOCS;
                return ;
            }

            // If first-time skip distance is any predictor of
            // scorer sparseness, then we should always try to skip first on
            // those scorers.
            // Keep last scorer in it's last place (it will be the first
            // to be skipped on), but reverse all of the others so that
            // they will be skipped on in order of original high skip.
            int end = scorers.Length - 1;
            int max = end >> 1;
            for (int i = 0; i < max; i++)
            {
                Scorer tmp = scorers[i];
                int idx = end - i - 1;
                scorers[i] = scorers[idx];
                scorers[idx] = tmp;
            }
        }

 public static Scorer Wrap(Random random, Scorer other)
 {
     if (other == null || other is AssertingScorer)
     {
         return other;
     }
     AssertingScorer assertScorer = new AssertingScorer(random, other);
     ASSERTING_INSTANCES[other] = new WeakReference(assertScorer);
     return assertScorer;
 }

	    /// <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);
		}

		/// <summary> Creates a new instance of DisjunctionMaxScorer
		/// 
		/// </summary>
		/// <param name="tieBreakerMultiplier">Multiplier applied to non-maximum-scoring subqueries for a
		/// document as they are summed into the result.
		/// </param>
		/// <param name="similarity">-- not used since our definition involves neither coord nor terms
		/// directly
		/// </param>
		/// <param name="subScorers">The sub scorers this Scorer should iterate on
		/// </param>
		/// <param name="numScorers">The actual number of scorers to iterate on. Note that the array's
		/// length may be larger than the actual number of scorers.
		/// </param>
		public DisjunctionMaxScorer(float tieBreakerMultiplier, Similarity similarity, Scorer[] subScorers, int numScorers):base(similarity)
		{
			
			this.tieBreakerMultiplier = tieBreakerMultiplier;
			// The passed subScorers array includes only scorers which have documents
			// (DisjunctionMaxQuery takes care of that), and their nextDoc() was already
			// called.
			this.subScorers = subScorers;
			this.numScorers = numScorers;
			
			Heapify();
		}

		internal void  Add(Scorer scorer)
		{
			if (length >= scorers.Length)
			{
				// grow the array
				Scorer[] temps = new Scorer[scorers.Length * 2];
				Array.Copy(scorers, 0, temps, 0, length);
				scorers = temps;
			}
			last += 1;
			length += 1;
			scorers[last] = scorer;
		}

 public override int Advance(int target)
 {
     if (reqScorer == null)
     {
         return doc = NO_MORE_DOCS;
     }
     if (exclDisi == null)
     {
         return doc = reqScorer.Advance(target);
     }
     if (reqScorer.Advance(target) == NO_MORE_DOCS)
     {
         reqScorer = null;
         return doc = NO_MORE_DOCS;
     }
     return doc = ToNonExcluded();
 }