/home/palakars/workspace-inprogress/code-in-progress/aitools3/aitools3-aq-invertedindex-cpp/src/core/Iterator.hpp

Go to the documentation of this file.

/* Copyright (C) 2010 webis.de
 * All rights reserved.
 */
#ifndef AITOOLS_INVERTEDINDEX_ITERATOR_HPP
#define AITOOLS_INVERTEDINDEX_ITERATOR_HPP

#include "Quantile.hpp"
#include "Exception.hpp"
#include "ByteBuffer.hpp"
#include "NonCopyable.hpp"
#include <boost/shared_ptr.hpp>
#include <climits>
#include <cstdio> // std::ftell, std::fclose

namespace aitools {
namespace invertedindex {

class Iterator : public NonCopyable {

public: // nested types

        typedef uint16_t value_size_t;

        typedef std::vector<value_size_t> SizeVector;

        typedef boost::shared_ptr<Iterator> SharedPointer;

        struct Header
        {
                Header()
                :   value_count(0),
                        value_size(0),
                        checksum(0),
                        payload(0)
                {}
                uint32_t value_count;
                uint16_t value_size;
                uint16_t checksum;
                uint32_t payload;
        };

        struct Chunk
        {
                Chunk()
                :       buffer(new ByteBuffer),
                        offset(0),
                        begin(0),
                        end(0)
                {}
                Chunk(ByteBuffer* buffer)
                :       buffer(buffer),
                        offset(0),
                        begin(0),
                        end(0)
                {
                        assert(buffer != NULL);
                }
                ~Chunk()
                {
                        delete buffer;
                }
                ByteBuffer* buffer;
                size_t      offset;
                size_t      begin;
                size_t      end;
        };

        struct Page
        {
                Page()
                :       offset(0),
                        file(NULL)
                {}
                Page(FILE* file)
                :       offset(0),
                        file(file)
                {
                        assert(file != NULL);
                        offset = std::ftell(file);
                }
                ~Page()
                {
                        if (file != NULL)
                        {
                                std::fclose(file);
                                file = NULL;
                        }
                }
                size_t offset;
                FILE*  file;
        };

public: // class data

        static const size_t max_chunk_size      = 10 * 1024 * 1024; // 10 MB
        static const size_t sizeof_value_size_t = sizeof(value_size_t);
        static const size_t sizeof_header       = sizeof(Header);

public: // c'tor / d'tor

        Iterator();

        Iterator(const Header& header, FILE* page);

        Iterator(const Header& header, ByteBuffer* buffer);

        Iterator(const Header& header, SizeVector* value_sizes, FILE* page);

        Iterator(const Header& header, SizeVector* value_sizes, ByteBuffer* buffer);

        ~Iterator();

public: // member

        void advance();

        uint16_t checksum() const;

        const Chunk& chunk() const;

        const SizeVector& value_sizes() const;

        const Header& header() const;

        inline bool is_paged() const
        {
                return page_.file != NULL;
        }

        inline bool is_valid() const
        {
                return index_ != header_.value_count;
        }

        size_t length() const;

        size_t payload() const;

        void rewind();

        inline size_t size() const
        {
                return header_.value_size ? header_.value_size : (*vsizes_)[index_];
        }

        bool swap() throw (std::runtime_error);

        inline const char* value() const
        {
                return chunk_.buffer->data() + chunk_.offset;
        }

private: // data

        Header      header_;
        SizeVector* vsizes_;
        Chunk       chunk_;
        Page        page_;
        size_t      index_;

};

} // namespace invertedindex
} // namespace aitools

#endif // AITOOLS_INVERTEDINDEX_ITERATOR_HPP

---