slice.h

Go to the documentation of this file.

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

#include <string.h>

#include <iostream>

#include "asserts.h"
#include "allocator_pool.h"

namespace JASS
    {
    class slice
        {
        protected:
            void *pointer;          
            size_t length;                  
            
        public:
            /*
                SLICE::SLICE()
                --------------
            */
            slice(void *pointer = nullptr, size_t length = 0) :
                pointer(pointer),
                length(length)
                {
                /* Nothing */
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(void *start, void *end) :
                pointer(start),
                length((uint8_t *)end - (uint8_t *)start)
                {
                /* Nothing */
                }
            /*

                SLICE::SLICE()
                --------------
            */
            slice(const char *message) :
                pointer((void *)message),
                length(strlen(message))
                {
                /* Nothing */
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, void *start, void *end)
                {
                length = (uint8_t *)end - (uint8_t *)start;
                pointer = (void *)pool.malloc(length);
                memcpy(pointer, start, length);
                }
            
            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, const char *start, const char *end)
                {
                length = end - start;
                pointer = (void *)pool.malloc(length + 1);
                memcpy(pointer, start, length);
                ((char *)pointer)[length] = '\0';
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, const unsigned char *start, const unsigned char *end)
                {
                length = end - start;
                pointer = (void *)pool.malloc(length + 1);
                memcpy(pointer, start, length);
                ((char *)pointer)[length] = '\0';
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, const char *start)
                {
                length = strlen(start);
                pointer = (void *)pool.malloc(length + 1);
                memcpy(pointer, start, length);
                ((char *)pointer)[length] = '\0';
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, const unsigned char *start)
                {
                length = strlen(reinterpret_cast<const char *>(start));
                pointer = (void *)pool.malloc(length + 1);
                memcpy(pointer, start, length);
                ((char *)pointer)[length] = '\0';
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, const slice &from)
                {
                length = from.size();
                pointer = (void *)pool.malloc(length);
                memcpy(pointer, from.address(), length);
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool, size_t bytes) :
                pointer((void *)pool.malloc(bytes)),
                length(bytes)
                {
                /* Nothing */
                }

            /*
                SLICE::SLICE()
                --------------
            */
            slice(allocator &pool):
                pointer(nullptr),
                length(0)
                {
                /* Nothing */
                }

            /*
                SLICE::CLEAR()
                --------------
            */
            void clear(void)
                {
                length = 0;
                pointer = nullptr;
                }



            /*
                SLICE::OPERATOR=()
                -------------------
            */
            slice &operator=(const slice &with)
                {
                pointer = with.pointer;
                length = with.length;

                return *this;
                }

            /*
                SLICE::SIZE()
                -------------
            */
            size_t size(void) const
                {
                return length;
                }
            
            /*
                SLICE::ADDRESS()
                ----------------
            */
            void *address(void) const
                {
                return pointer;
                }
            
            /*
                SLICE::RESIZE()
                ---------------
            */
            void resize(size_t new_size)
                {
                length = new_size;
                }
            
            /*
                SLICE::OPERATOR[]()
                -------------------
            */
            uint8_t &operator[](size_t index) const
                {
                return ((uint8_t *)pointer)[index];
                }
            
            /*
                SLICE::STRICT_WEAK_ORDER_LESS_THAN()
                ------------------------------------
            */
            static bool strict_weak_order_less_than(const slice &me, const slice &with)
                {
                if (me.size() == with.size())
                    return memcmp(me.address(), with.address(), me.size()) < 0;
                else if (me.size() < with.size())
                    {
                    auto cmp = memcmp(me.address(), with.address(), me.size());
                    if (cmp == 0)
                        return true;
                    else
                        return cmp < 0 ? true : false;
                    }
                else
                    {
                    auto cmp = memcmp(me.address(), with.address(), with.size());
                    if (cmp == 0)
                        return false;
                    else
                        return cmp < 0 ? true : false;
                    }
                }

            /*
                SLICE::OPERATOR<()
                ------------------
            */
            bool operator<(const slice &with) const
                {
                if (size() < with.size())
                    return true;
                if (size() > with.size())
                    return false;
                return memcmp(address(), with.address(), size()) < 0;
                }

            /*
                SLICE::OPERATOR>()
                ------------------
            */
            bool operator>(const slice &with) const
                {
                if (size() > with.size())
                    return true;
                if (size() < with.size())
                    return false;
                return memcmp(address(), with.address(), size()) > 0;
                }

            /*
                SLICE::OPERATOR==()
                -------------------
            */
            bool operator==(const slice &with) const
                {
                if (size() != with.size())
                    return false;
                return memcmp(address(), with.address(), size()) == 0;
                }

            /*
                SLICE::UNITTEST()
                -----------------
            */
            static void unittest(void)
                {
                slice chunk1;
                JASS_assert(chunk1.address() == nullptr && chunk1.size() == 0);
                
                slice chunk2((char *)unittest, (char *)unittest + 5);
                JASS_assert(chunk2.address() == unittest && chunk2.size() == 5);
                
                allocator_pool pool;
                char data[6];
                slice chunk3(pool, (void *)data, (void *)((uint8_t *)data + 5));
                JASS_assert(pool.size() == 5 && chunk3.size() == 5);
                
                const char *message = "here there and everywhere";
                slice chunk4(pool, message, message + 4);
                JASS_assert(pool.size() == 10 && chunk4.size() == 4);
                
                JASS_assert(chunk4[1] == 'e' && &chunk4[1] == (unsigned char *)chunk4.address() + 1);

                slice chunk5(pool, message);
                JASS_assert(pool.size() == 36 && strcmp((char *)chunk5.address(), message) == 0);

                slice chunk6(pool, 10);
                JASS_assert(pool.size() == 46 && chunk6.size() == 10);
                
                chunk6.resize(5);
                JASS_assert(chunk6.size() == 5);

                JASS_assert(slice("a") < slice("b"));
                JASS_assert(!(slice("b") < slice("a")));

                JASS_assert(!(slice("aa") < slice("b")));
                JASS_assert(slice("b") < slice("aa"));

                JASS_assert(!(slice("a") > slice("b")));
                JASS_assert(slice("b") > slice("a"));

                JASS_assert(slice("aa") > slice("b"));
                JASS_assert(!(slice("b") > slice("aa")));

                JASS_assert(slice("a") == slice("a"));
                JASS_assert(!(slice("aa") == slice("a")));

                /*
                    exhaustively test strict_weak_order_less_than() which emilates a strcmp()
                */
                JASS_assert(strict_weak_order_less_than(slice("aa"), slice("aa")) == false);
                JASS_assert(strict_weak_order_less_than(slice("a"), slice("aa")) == true);
                JASS_assert(strict_weak_order_less_than(slice("b"), slice("aa")) == false);
                JASS_assert(strict_weak_order_less_than(slice("a"), slice("bb")) == true);
                JASS_assert(strict_weak_order_less_than(slice("aa"), slice("a")) == false);
                JASS_assert(strict_weak_order_less_than(slice("aa"), slice("b")) == true);
                JASS_assert(strict_weak_order_less_than(slice("bb"), slice("a")) == false);

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

    /*
        OPERATOR<<()
        ------------
    */
    inline std::ostream &operator<<(std::ostream &stream, const slice &data)
        {
        stream.write((char *)data.address(), data.size());
        return stream;
        }

    }