compress_integer.h

Go to the documentation of this file.

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

#include <stdint.h>
#include <stdlib.h>

#include <vector>

#include "asserts.h"

namespace JASS
    {
    /*
        CLASS COMPRESS_INTEGER
        ----------------------
    */
    class compress_integer
        {
        private:
            static constexpr int MAX_D_GAP = 64;                    

        public:
            typedef uint32_t integer;                                   
            #define JASS_COMPRESS_INTEGER_BITS_PER_INTEGER 32   

        public:
            /*
                COMPRESS_INTEGER::COMPRESS_INTEGER()
                ------------------------------------
            */
            compress_integer()
                {
                /* Nothing */
                }
            /*
                COMPRESS_INTEGER::COMPRESS_INTEGER()
                ------------------------------------
            */
            virtual ~compress_integer()
                {
                /* Nothing */
                }

            /*
                COMPRESS_INTEGER::D1_ENCODE()
                -----------------------------
            */
            static size_t d1_encode(integer *encoded, const integer *source, size_t source_integers)
                {
                integer prior = 0;
                const integer *end = source + source_integers;

                for (const integer *current = source; current < end; current++)
                    {
                    /*
                        This is done in this order so that the encoded and source buffers can be the same array.
                    */
                    integer d1 = *current - prior;
                    prior = *current;
                    *encoded++ = d1;
                    }
                return source_integers;
                }

            /*
                COMPRESS_INTEGER::D1_DECODE()
                -----------------------------
            */
            static size_t d1_decode(integer *decoded, const integer *source, size_t source_integers)
                {
                integer sum = 0;
                const integer *end = source + source_integers;

                for (const integer *current = source; current < end; current++)
                    {
                    sum += *current;
                    *decoded++ = sum;
                    }

                return source_integers;
                }

            /*
                COMPRESS_INTEGER::DN_ENCODE()
                -----------------------------
            */
            static size_t dn_encode(integer *encoded, const integer *source, size_t source_integers, size_t n = 1)
                {
                JASS_assert(n < MAX_D_GAP);     // Verify that n isn't too large.
                integer prior[MAX_D_GAP];   // temporary buffer of unencoded values stored so that source cab equal encoded (the pointers, that is)

                /*
                    The first n are not encoded, so write then directly into the output buffer
                */
                std::copy(source, source + n, encoded);

                /*
                    In order to be able to use the input buffer as the output buffer we cycle through an internal buffer
                */
                std::copy(source, source + n, prior);

                /*
                    The remainder are differences.  We'll use two pointers to keep track of the sum and one for where we write into.
                */
                integer *into = encoded + n;
                const integer *current = source + n;
                size_t where = 0;

                const integer *end = source + source_integers;
                while (current < end)
                    {
                    integer difference = *current - prior[where];
                    prior[where] = *current;
                    *into = difference;
                    into++;
                    current++;
                    where = (where + 1) % n;
                    }

                return source_integers;
                }

            /*
                COMPRESS_INTEGER::DN_DECODE()
                -----------------------------
            */
            static size_t dn_decode(integer *decoded, const integer *source, size_t source_integers, size_t n = 1)
                {
                /*
                    The first n are not encoded, so write then directly into the output buffer
                */
                std::copy(source, source + n, decoded);

                /*
                    The remainder are encoded so decode them
                */
                integer *into = decoded + n;
                integer *previous = decoded;
                const integer *current = source + n;

                const integer *end = decoded + source_integers;
                while (into < end)
                    *into++ = *previous++ + *current++;

                return source_integers;
                }

            /*
                COMPRESS_INTEGER::ENCODE()
                --------------------------
            */
            virtual size_t encode(void *encoded, size_t encoded_buffer_length, const integer *source, size_t source_integers) = 0;
            
            /*
                COMPRESS_INTEGER::DECODE()
                --------------------------
            */
            virtual void decode(integer *decoded, size_t integers_to_decode, const void *source, size_t source_length) = 0;

            /*
                COMPRESS_INTEGER::UNITTEST_ONE()
                --------------------------------
            */
            static void unittest_one(compress_integer &encoder, const std::vector<uint32_t> &sequence);

            /*
                COMPRESS_INTEGER::UNITTEST()
                ----------------------------
            */
            static void unittest(compress_integer &compressor, uint32_t staring_from = 0);
        } ;
    }