FieldInfoList.hpp

Go to the documentation of this file.

/*==========================================================================
 * Copyright (c) 2007 Carnegie Mellon University.  All Rights Reserved.
 *
 * Use of the Lemur Toolkit for Language Modeling and Information Retrieval
 * is subject to the terms of the software license set forth in the LICENSE
 * file included with this software, and also available at
 * http://www.lemurproject.org/license.html
 *
 *==========================================================================
 *
 * 26 Sep 2007 - mjh - initial file start
 */


#ifndef _FIELDINFOLIST_HPP
#define _FIELDINFOLIST_HPP

#include "IndexTypes.hpp"
#include "lemur-platform.h"
#include "Exception.hpp"

namespace lemur
{
  namespace api 
  {
    

    class FieldInfo {
    public:
      int begin;
      int end;
      int id;
      int ordinal;
      int parentOrdinal;
      INT64 number;

      inline FieldInfo() {}

      inline FieldInfo(int _begin, int _end, int _id, INT64 _number=0, int _ordinal=0, int _parentOrdinal=0) :
      begin(_begin), end(_end), id(_id),
      ordinal(_ordinal), parentOrdinal(_parentOrdinal), number(_number) {  }

      inline FieldInfo(const FieldInfo &c) : 
      begin(c.begin), end(c.end), id(c.id),
      ordinal(c.ordinal), parentOrdinal(c.parentOrdinal), number(c.number) {  }


    };



    class FieldInfoList {
    public:
      virtual ~FieldInfoList() {}

    protected:
      // Helper functions for iterator, subclasses should override
      virtual FieldInfo* newElement() const { return new FieldInfo(); }
      virtual FieldInfo* getElement(FieldInfo* elem, POS_T position) const =0;
      virtual void assignElement(FieldInfo* to, FieldInfo* from) const { *to = *from; }
      virtual POS_T beginPosition() const =0;
      virtual POS_T endPosition() const =0;
      virtual POS_T nextPosition(POS_T position) const =0;

    public:
      // Single, internal iteration
      virtual void startIteration()=0;

      virtual bool hasMore()const=0;

      virtual FieldInfo *nextEntry()const=0;

      virtual int size()=0;

      virtual FieldInfo* operator[] (int index)=0;

      // C++ style forward input (readonly) iterator
      class iterator : std::iterator<std::input_iterator_tag, FieldInfo> {
      public:
        iterator() : list(NULL), position(0), current(NULL) {}
        iterator(const iterator& other) {
          list = other.list;
          position = other.position;
          if ((list) && (other.current) ) {
            current = list->newElement();
            list->assignElement(current, other.current);  // list knows element class
          } else {
            current = NULL;
          }
        }
        iterator(const FieldInfoList* til, POS_T pos) : list(til), position(pos) {
          if (list) {
            if (position != list->endPosition()) {
              current = list->newElement();   // get new element
              current = list->getElement(current, position);
            } else {
              current = NULL;
            }
          }
        }

        ~iterator() {
          delete(current);
        }

        FieldInfo& operator*() { return *current; }
        FieldInfo* operator->() { return current; }
        iterator& operator++() {
          position = list->nextPosition(position);
          if (position != list->endPosition())
            current = list->getElement(current, position);
          return *this;
        }
        // identical to prefix version
        iterator& operator++(int) {
          return operator++();
        }
        bool operator==(const iterator& other) const {
          return (list == other.list) && (position == other.position);
        }
        bool operator!=(const iterator& other) const {
          return (list != other.list) || (position != other.position);
        }
        iterator& operator=(const iterator& other) {
          list = other.list;
          position = other.position;
          if ((list) && (other.current)) {
            if (!current)
              current = list->newElement();
            list->assignElement(current, other.current);  // list knows element class
          } else {
            delete(current);
            current=NULL;
          }
          return *this;
        }
        void seek(POS_T pos) {
          position = pos;
          if (position != list->endPosition()) {
            if (!current)
              current = list->newElement();
            current = list->getElement(current, position);
          } else {
            delete(current);
            current = NULL;
          }
        }

      protected:
        const FieldInfoList* list;  // list associated with this iterator
        POS_T position;     // current position in list
        FieldInfo* current;   // current element of list
      }; // end of nested iterator declaration
 
      iterator& begin() const { 
        iterator it(this, beginPosition());
        itbegin = it;
        return itbegin;
      }
      iterator& end() const { 
        iterator it(this, endPosition());
        itend = it;
        return itend;
      }

    protected:
      mutable FieldInfoList::iterator itbegin;  // iterator at head of list
      mutable FieldInfoList::iterator itend;    // iterator at end of list
      friend class iterator;
    };
  }
}


#endif

---