index_postings_impact.h

Go to the documentation of this file.

/*
    INDEX_POSTINGS_IMPACT.H
    -----------------------
    Copyright (c) 2017 Andrew Trotman
    Released under the 2-clause BSD license (See:https://en.wikipedia.org/wiki/BSD_licenses)
*/
#pragma once

#include <vector>
#include <limits>
#include <sstream>

#include "allocator.h"
#include "compress_integer.h"

namespace JASS
    {
    /*
        CLASS INDEX_POSTINGS_IMPACT
        ---------------------------
    */
    class index_postings_impact
        {
        friend class index_postings;
        
        public:
#ifdef NEVER
            typedef uint8_t impact_type;                                    
            static constexpr size_t largest_impact = std::numeric_limits<impact_type>::max();       
            static constexpr size_t smallest_impact = 1;                
#else
            typedef uint16_t impact_type;                                   
            static constexpr size_t largest_impact = 1024;          
            static constexpr size_t smallest_impact = 1;                
#endif

        public:
            /*
                CLASS INDEX_POSTINGS_IMPACT::IMPACT
                -----------------------------------
            */
            class impact
                {
                public:
                    impact_type impact_score;                               
                    compress_integer::integer  *start;                  
                    compress_integer::integer  *finish;                 

                    /*
                        INDEX_POSTINGS_IMPACT::IMPACT::IMPACT
                        -------------------------------------
                    */
                    impact() :
                        impact_score(0),
                        start(nullptr),
                        finish(nullptr)
                        {
                        /* Nothing */
                        }

                public:
                    /*
                        INDEX_POSTINGS_IMPACT::IMPACT::BEGIN()
                        --------------------------------------
                    */
                    compress_integer::integer *begin(void) const
                        {
                        return start;
                        }

                    /*
                        INDEX_POSTINGS_IMPACT::IMPACT::END()
                        ------------------------------------
                    */
                    compress_integer::integer *end(void) const
                        {
                        return finish;
                        }

                    /*
                        INDEX_POSTINGS_IMPACT::IMPACT::SIZE()
                        -------------------------------------
                    */
                    compress_integer::integer size(void) const
                        {
                        return static_cast<compress_integer::integer>(finish - start);
                        }
                };

        private:
            /*
                CLASS INDEX_POSTINGS_IMPACT::REVERSE_ITERATOR
                ---------------------------------------------
            */
            class reverse_iterator
                {
                private:
                    impact *address;                

                public:
                    /*
                         INDEX_POSTINGS_IMPACT::REVERSE_ITERATOR:REVERSE_ITERATOR
                        ---------------------------------------------------------
                    */
                    reverse_iterator(impact *address):
                        address(address)
                        {
                        /* Nothing */
                        }

                    /*
                         INDEX_POSTINGS_IMPACT::REVERSE_ITERATOR:OPERATOR!=()
                        -----------------------------------------------------
                    */
                    bool operator!=(const reverse_iterator &other) const
                        {
                        return address != other.address;
                        }

                    /*
                         INDEX_POSTINGS_IMPACT::REVERSE_ITERATOR:OPERATOR*()
                        ----------------------------------------------------
                    */
                    impact &operator*()
                        {
                        return *address;
                        }

                    /*
                         INDEX_POSTINGS_IMPACT::REVERSE_ITERATOR:OPERATOR++()
                        -----------------------------------------------------
                    */
                    const reverse_iterator &operator++()
                        {
                        address--;
                        return *this;
                        }
                };

        protected:
            allocator &memory;                          
            size_t number_of_impacts;                   
            impact impacts[largest_impact + 1];     
            size_t number_of_postings;                  
            compress_integer::integer *postings;    
            compress_integer::integer *document_ids;                    
            index_postings_impact::impact_type *term_frequencies;   
            size_t temporary_size;                                          
            uint8_t *temporary;                                             

        public:
            /*
                INDEX_POSTINGS_IMPACT::INDEX_POSTINGS_IMPACT()
                ----------------------------------------------
            */
            index_postings_impact(size_t document_count, allocator &memory):
                memory(memory),
                number_of_impacts(0),
                number_of_postings(document_count),
                postings(static_cast<decltype(postings)>(memory.malloc((document_count + largest_impact + 1) * sizeof(*postings)))),            // longest length is total_postings + all impacts + 1
                document_ids((decltype(document_ids))memory.malloc(document_count * sizeof(*document_ids))),
                term_frequencies((decltype(term_frequencies))memory.malloc(document_count * sizeof(*term_frequencies))),
                temporary_size(document_count * (sizeof(*document_ids) / 7 + 1) * sizeof(*temporary)),
                temporary((decltype(temporary))memory.malloc(temporary_size))           // enough space to decompress variable-byte encodings
                {
                /* Nothing */
                }

            /*
                INDEX_POSTINGS_IMPACT::SET_IMPACT_COUNT()
                -----------------------------------------
            */
            void set_impact_count(size_t number_of_impacts)
                {
                this->number_of_impacts = number_of_impacts;
                }

            /*
                INDEX_POSTINGS_IMPACT::GET_POSTINGS()
                -------------------------------------
            */
            compress_integer::integer *get_postings(void)
                {
                return postings;
                }

            /*
                INDEX_POSTINGS_IMPACT::OPERATOR[]()
                -----------------------------------
            */
            compress_integer::integer &operator[](size_t index) const
                {
                return postings[index];
                }

            /*
                INDEX_POSTINGS_IMPACT::HEADER()
                -------------------------------
            */
            void header(size_t index, impact_type score, compress_integer::integer *postings_start, compress_integer::integer *postings_end)
                {
                impacts[index].impact_score = score;
                impacts[index].start = postings_start;
                impacts[index].finish = postings_end;
                }

            /*
                INDEX_POSTINGS_IMPACT::IMPACT_SIZE()
                ------------------------------------
            */
            size_t impact_size(void) const
                {
                return number_of_impacts;
                }

            /*
                INDEX_POSTINGS_IMPACT::BEGIN()
                ------------------------------
            */
            const impact *begin(void) const
                {
                return &impacts[0];
                }

            /*
                INDEX_POSTINGS_IMPACT::END()
                ----------------------------
            */
            const impact *end(void) const
                {
                return &impacts[number_of_impacts];
                }

            /*
                INDEX_POSTINGS_IMPACT::RBEGIN()
                -------------------------------
            */
            const auto rbegin(void) const
                {
                return reverse_iterator((impact *)(&impacts[number_of_impacts - 1]));
                }

            /*
                INDEX_POSTINGS_IMPACT::REND()
                ----------------------------
            */
            const auto rend(void) const
                {
                return reverse_iterator((impact *)(&impacts[0] - 1));
                }

            /*
                INDEX_POSTINGS_IMPACT::TEXT_RENDER()
                ------------------------------------
            */
            void text_render(std::ostream &stream)
                {
                stream << "{[";
                for (const auto &header : *this)
                    {
                    stream << header.impact_score << ":";
                    for (const auto posting : header)
                        stream << posting << " ";
                    }
#ifdef NEVER
                stream << "]\n[";
                for (size_t index = 0; index < number_of_postings; index++)
                    stream << postings[index] << " ";
                stream << "]}";
#else
                stream << "]}";
#endif
                }

            /*
                INDEX_POSTINGS_IMPACT::UNITTEST()
                ---------------------------------
            */
            static void unittest(void)
                {
                allocator_pool memory;
                index_postings_impact postings(7, memory);

                /*
                    Set up some postings
                */
                postings[0] = 255;          // impact
                postings[1] = 10;               // docid
                postings[2] = 0;                // termiator
                postings[3] = 128;          // impact
                postings[4] = 2;                // docid
                postings[5] = 5;                // docis
                postings[6] = 0;                // terminator

                /*
                    Set up the headers
                */
                postings.header(0, 255, &postings[1], &postings[2]);
                postings.header(1, 128, &postings[4], &postings[6]);
                postings.set_impact_count(2);

                /*
                    Check the data got into the right places.
                */
                const compress_integer::integer answer[] = {255, 10, 0, 128, 2, 5, 0};
                JASS_assert(memcmp(&postings[0], answer, sizeof(answer)) == 0);

                JASS_assert(postings.impacts[0].impact_score == 255);
                JASS_assert(postings.impacts[0].start == &postings.postings[1]);
                JASS_assert(postings.impacts[0].finish == &postings.postings[2]);

                JASS_assert(postings.impacts[1].impact_score == 128);
                JASS_assert(postings.impacts[1].start == &postings.postings[4]);
                JASS_assert(postings.impacts[1].finish == &postings.postings[6]);

                JASS_assert(postings.number_of_postings == 7);
                JASS_assert(postings.impact_size() == 2);

                /*
                    Check iteration
                */
                std::string serialised_answer = "255:10 \n128:2 5 \n";
                std::stringstream output;
                for (const auto &header : postings)
                    {
                    output << static_cast<int>(header.impact_score) << ":";
                    for (const auto &document_id : header)
                        output << document_id << " ";
                    output << '\n';
                    }

                JASS_assert(output.str() == serialised_answer);

                puts("index_postings_impact::PASSED");
                }
        };

    /*
        OPERATOR<<()
        ------------
    */
    inline std::ostream &operator<<(std::ostream &stream, index_postings_impact &data)
        {
        data.text_render(stream);
        return stream;
        }
    }