Tanl Linguistic Pipeline

search/ixe/Common/IndexTable.h

/*
**      IXE
**      Common/IndexTable.h
** ----------------------------------------------------------------------
**      Copyright (c) 2000, 2001  Ideare SpA. All rights reserved.
**      Copyright (c) 2000, 2001  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

#ifndef IXE_IndexTable_H
#define IXE_IndexTable_H

// Settings
#include "platform.h"

// standard
#include <cstddef>                              /* for ptrdiff_t */
#include <iterator>
#include <sys/types.h>                          /* for off_t */

// local
#include "include/ixe.h"
#include "io/mappedFile.h"

using namespace IXE::io;

namespace IXE {

struct FileFormat {
  short major;
  short minor;

  bool operator ==(FileFormat const& other) const {
    return (major == other.major && minor == other.minor);
  }

  inline bool operator !=(FileFormat const& other) const {
    return !(*this == other);
  }

  bool  isSwapped(FileFormat const& other) const {
    return ((major >> 8 | major << 8) == other.major &&
            (minor >> 8 | minor << 8) == other.minor);
  }
};

struct FileHeader {
  FileFormat    format;
  Count         num_docs;       // number of indexed documents
  Count         num_columns;    // number of columns
# ifdef __alpha
  Count         _align;
# endif

  FileHeader() { }

  FileHeader(FileFormat& format, Count num_docs, Count num_columns) :
    format(format), num_docs(num_docs), num_columns(num_columns)
  { }

  inline int get_num_docs() const {
    return
#     if 0 // WORDS_BIGENDIAN
      (fh->format.isSwapped(fileFormatVersion)) ? int4get(&num_docs) :
#     endif
      num_docs;
  }

  inline int get_num_columns() const {
    return
#     if 0 // WORDS_BIGENDIAN
      (fh->format.isSwapped(fileFormatVersion)) ? int4get(&num_columns) :
#     endif
      num_columns;
  }
};

extern FileFormat fileFormatVersion;

// FIXME: should go inside class IndexTable
enum index_id {
  stop_word_index        = 0,
  color_index            = 1,
};

template <class Entry>
class IndexTable
{
public:

  typedef Size          size_type;
  typedef ptrdiff_t     difference_type;

  typedef Entry         value_type;
  typedef Entry*        pointer;
  typedef Entry const*  const_pointer;
  typedef Entry&        reference;
  typedef Entry const&  const_reference;


  IndexTable() : table(0) { }
  IndexTable(mappedFile const &file, index_id id);


  void                  access(mappedFile const& file, off32_t& offset) {
    begin_ = file.begin();
    off32_t const *p = reinterpret_cast<off32_t const *>(begin_ + offset);
    entries = p[0];             // FIXME: ENDIAN
    table = reinterpret_cast<Entry const *>(&p[1]);
    // Advance offset to next table
    offset += sizeof(entries) + (entries + 1) * sizeof(Entry)
      + *reinterpret_cast<off32_t const*>(&table[entries]); // size of index data
  }

  size_type             size() const { return entries; }

  const_pointer         operator [](size_type i) const { return &table[i]; }


  class const_iterator :
    public std::iterator<std::random_access_iterator_tag, 
                         value_type, difference_type>
  {
  public:
    IndexTable<Entry> const*    index;
    size_type                   i;

  protected:
    const_iterator(IndexTable const* index, size_type i) :
      index(index), i(i) { }
    friend class IndexTable;

  public:
    const_iterator() { }

    const_pointer       operator *() const { return (*index)[i]; }
    const_iterator&     operator ++() { ++i; return *this; }
    const_iterator&     operator --() { --i; return *this; }
    // postfix versions:
    const_iterator      operator ++(int) { return const_iterator(index, i++); }
    const_iterator      operator --(int) { return const_iterator(index, i--); }
    const_iterator&     operator +=(int n) { i += n; return *this; }
    const_iterator&     operator -=(int n) { i -= n; return *this; }

    bool
    operator ==(const_iterator const& j) {
      return i == j.i;
    }
    bool
    operator !=(const_iterator const& j) {
      return !(*this == j);
    }
    bool
    operator <(const_iterator const& j) {
      return i < j.i;
    }

    typename const_iterator::difference_type
    operator -(const_iterator const& j) {
      return this->i - j.i;
    }

    friend inline bool
    operator ==(const_iterator const& i, const_iterator const& j) {
      return i.i == j.i;
    }
    friend inline bool
    operator !=(const_iterator const& i, const_iterator const& j) {
      return !(i == j);
    }

    friend const_iterator
    operator +(const_iterator const& i, int n) {
      return typename IndexTable<Entry>::const_iterator(i.index, i.i + n);
    }
    friend const_iterator
    operator -(const_iterator const& i, int n) {
      return IndexTable<Entry>::const_iterator(i.index, i.i - n);
    }
    friend typename const_iterator::difference_type
    operator -(const_iterator const& i, const_iterator const& j) {
      return i.i - j.i;
    }
    size_type position() { return i; }
  };

# if defined(__DECCXX) || defined(_MSC_VER) || (__GNUC__ >= 3)
  friend class const_iterator;
# else
  friend class IndexTable::const_iterator;
# endif

  const_iterator begin() const {
    return const_iterator(this, 0);
  }
  const_iterator end() const {
    return const_iterator(this, entries);
  }
  const_iterator position_at(size_type i) const {
    return const_iterator(this, i);
  }
protected:
  mappedFile::const_iterator    begin_;
  size_type                     entries;
  Entry const*                  table;
};

class BigramTable : public IndexTable<TermID> {
public:
  void                  access(mappedFile const& file, off32_t& offset);
  value_type            operator [](size_type i) const { return table[i]; }
  value_type&           operator [](size_type i) {
    return ((value_type*)table)[i];
  }
};

class StringTable : public IndexTable<Size> {
public:
  StringTable() { }

  StringTable(mappedFile const& file, index_id id);

  // redefine so that operator* uses our operator[]:
  class const_iterator : public IndexTable<Size>::const_iterator
  {
  public:
    const_iterator() { }

    const_iterator(StringTable const* index_, size_type i_) :
      IndexTable<Size>::const_iterator(index_, i_) { }

    // lower_bound needs this
    const_iterator&     operator ++() { ++i; return *this; }

    char const*         operator *() const {
      return (*(StringTable*)index)[i];
    }

#   ifdef __DECCXX
    StringTable::const_iterator&
      operator =(IndexTable<Size>::const_iterator const& other) {
      index = other.index;
      i = other.i;
      return *this;
    }
#   endif
  };

  char const*           operator [](size_type i) const {
    return begin_ + table[i];
  }

  const_iterator begin() const {
    return const_iterator(this, 0);
  }
  const_iterator end() const {
    return const_iterator(this, entries);
  }
  const_iterator position_at(size_type i) const {
    return const_iterator(this, i);
  }

  // temporary patch. We should have separate stop_words for each column.
  void  clear() { entries = 0; }

};

} // namespace IXE

#endif  /* IXE_IndexTable_H */

 

Copyright © 2005-2011 G. Attardi. Generated on 4 Mar 2011 by doxygen 1.6.1.