sort.h

Go to the documentation of this file.

/*************************************************************
 **
 ** @file index/sort.h
 **
 ** Copyright (C) 2012  Xpace, LLC.  All rights reserved
 **
 ** www.xpace.net
 **
 **************************************************************/

#ifndef XPACE_SORT_H
#define XPACE_SORT_H

#include "index/reflist/reflist_bitmap.h"

namespace Xpace
{
  struct NullList
  {
    void add
      (uint64)
    {
    }
  };
  extern NullList null_list;   // to quiet GCC warning

  template <typename LIST = NullList>
  class SortToSink
  {
  public:
    SortToSink
      (const RefListCursor& searchResult,
       const std::vector<SortContext>& sort,
       LIST* list = &null_list) :
      state(new st(searchResult, sort, list))
    {
    }

    ~SortToSink
      ()
    {
    }

    int64 operator()
      (int64 doc)
    {
      return state->next(doc);
    }

    void complete
      ()
    {
      return state->complete();
    }

  private:
    class st
    {
    public:
      st
        (const RefListCursor& searchResult,    
         const std::vector<SortContext>& sort,
         LIST *list) :
        search_result((searchResult.hasRef(0), searchResult.constImpl()->makeRandom())),     // force result to be random
        sort(sort),
        sort_iter(sort[0].index->begin()),
        srlc(sort_iter.getRefList().impl()),
        sort_rlc(dynamic_cast<RLC_Index*>(srlc.impl())),
        list(list)
      {
        assert(sort_rlc);
      }

      int64 next
        (int64 doc)
      {
        while (1)
        {
          if (!*sort_rlc)
          {
            if (!sort_iter.move(1))
              return NDR_abort_true;
            srlc = sort_iter.getRefList();
            sort_rlc = dynamic_cast<RLC_Index*>(srlc.impl());
            assert(sort_rlc);
          }

          bool b;
          uint64 ref(*sort_rlc->getRef());
          if (search_result->hasRef(&b, ref), b)
          {
            list->add(doc = ref);
            sort_rlc->move(&b, 1);
            return doc;
          }
        }
      }

      void complete
        ()
      {
        while (1)
        {
          if (!*sort_rlc)
          {
            if (!sort_iter.move(1))
              return;
            srlc = sort_iter.getRefList();
            sort_rlc = dynamic_cast<RLC_Index*>(srlc.impl());
          }
          bool b;
          uint ref(*sort_rlc->getRef());
          if (search_result->hasRef(&b, ref), b)
            list->add(ref);
          sort_rlc->move(&b, 1);
        }
      }
      
    private:
      st
        (const st&);
      st& operator=
        (const st&);     

      const RLC_Bitmap* search_result;
      const std::vector<SortContext>& sort;
      Index::Iter sort_iter;
      RefListCursor srlc;
      RLC_Index* sort_rlc;
      
      LIST* list;
    };

    std::shared_ptr<st> state;
  };
}

#endif