libcruft-util/alloc/raw/linear.hpp

/*
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * Copyright 2015 Danny Robson <danny@nerdcruft.net>
 */

#ifndef CRUFT_UTIL_ALLOC_RAW_LINEAR_HPP
#define CRUFT_UTIL_ALLOC_RAW_LINEAR_HPP

#include "../../view.hpp"
#include "../../pointer.hpp"

#include <cstddef>
#include <iterator>

namespace cruft::alloc::raw {
    // allocate progressively across a buffer without concern for deallocation.
    // deallocation is a noop; the only way to free allocations is via reset.
    class linear {
    public:
        linear (const linear&) = delete;
        linear& operator= (const linear&) = delete;

        linear (linear&&);
        linear& operator= (linear&&);

        linear (cruft::view<std::byte*> _data);

        template <typename T>
        cruft::view<T*>
        allocate (size_t count)
        {
            auto const bytes = count * sizeof (T);
            if (m_cursor + bytes > m_end)
                throw std::bad_alloc ();

            auto ptr = m_cursor;
            m_cursor += bytes;
            return { cruft::cast::alignment<T*> (ptr), count };
        }


        template <typename T>
        cruft::view<T*>
        allocate (size_t count, size_t alignment)
        {
            auto const bytes = count * sizeof (T);

            auto ptr = cruft::align_up (m_cursor, alignment);
            if (ptr + bytes > m_end)
                throw std::bad_alloc ();

            m_cursor = ptr + bytes;

            return { cruft::cast::alignment<T*> (ptr), count };
        }

        template <typename T>
        void deallocate (cruft::view<T*> ptr)
        {
            (void)ptr;
        }

        std::byte* data (void);
        std::byte* begin (void);
        std::byte* end (void);
        std::byte* cursor (void);

        const std::byte* data (void) const;
        const std::byte* begin (void) const;
        const std::byte* end (void) const;
        const std::byte* cursor (void) const;

        size_t offset (const void*) const;

        template <typename ValueT>
        size_t
        offset (ValueT const *ptr) const
        {
            CHECK_MOD (reinterpret_cast<uintptr_t> (ptr),     sizeof (ValueT));
            CHECK_MOD (reinterpret_cast<uintptr_t> (data ()), sizeof (ValueT));

            return ptr - cruft::cast::alignment<ValueT const*> (data ());
        }

        template <typename T>
        size_t
        offset (cruft::view<T*> ptr) const
        {
            return offset (ptr.data ());
        }

        void reset (void);

        size_t capacity (void) const;
        size_t used     (void) const;
        size_t remain   (void) const;

    protected:
        // The begin and end iterators should be constant but that interferes
        // with move operators so we need to leave them mutable.
        std::byte *m_begin;
        std::byte *m_end;

        std::byte *m_cursor;
    };
}

#endif