Pointer 32bit
(library/util/pointer_32bit.hpp)

• View this file on GitHub
• Last update: 2023-05-13 02:46:54+09:00
• Include: #include "library/util/pointer_32bit.hpp"

Pointer 32bit

Required by

• Reversible Implicit Treap (library/datastructure/bbst/reversible_implicit_treap.hpp)
• Reversible Implicit Treap Base (library/datastructure/bbst/reversible_implicit_treap_base.hpp)
• Reversible Implicit Treap Dual Segtree (library/datastructure/bbst/reversible_implicit_treap_dual_segtree.hpp)
• Reversible Implicit Treap Lazy Segtree (library/datastructure/bbst/reversible_implicit_treap_lazy_segtree.hpp)
• Reversible Implicit Treap Segtree (library/datastructure/bbst/reversible_implicit_treap_segtree.hpp)
• Sortable Segment Tree (library/datastructure/segment_tree/sortable_segment_tree.hpp)

Verified with

• test/src/datastructure/bbst/reversible_implicit_treap/abc237_d.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap/dummy.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap/yuki649.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap_dual_segtree/dummy.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap_lazy_segtree/dummy.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap_lazy_segtree/dynamic_sequence_range_affine_range_sum.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap_segtree/abc238_f.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap_segtree/dummy.test.cpp
• test/src/datastructure/bbst/reversible_implicit_treap_segtree/range_reverse_range_sum.test.cpp
• test/src/datastructure/segment_tree/sortable_segment_tree/abc237_g.test.cpp
• test/src/datastructure/segment_tree/sortable_segment_tree/point_set_range_sort_range_composite.test.cpp

Code

#ifndef SUISEN_32BIT_POINTER
#define SUISEN_32BIT_POINTER

#include <vector>

namespace suisen {
    template <typename Object>
    struct ptr32 {
        static constexpr int null = -1;

        using object_type = Object;
        using pool_type = std::vector<object_type>;

        constexpr ptr32() : ptr(null) {}
        explicit constexpr ptr32(int ptr) : ptr(ptr) {}
        constexpr ptr32(std::nullptr_t) : ptr(null) {}

        object_type& operator*() const { return pool[ptr]; }
        object_type* operator->() const { return &pool[ptr]; }

        constexpr operator bool() const { return ptr != null; }
        constexpr operator int() const { return ptr; }

        constexpr bool is_not_null() const { return bool(*this); }
        constexpr bool is_null() const { return not bool(*this); }

        friend constexpr bool operator==(const ptr32& l, const ptr32& r) { return l.ptr == r.ptr; }
        friend constexpr bool operator!=(const ptr32& l, const ptr32& r) { return l.ptr != r.ptr; }
        friend constexpr bool operator<(const ptr32& l, const ptr32& r) { return l.ptr < r.ptr; }
        friend constexpr bool operator<=(const ptr32& l, const ptr32& r) { return l.ptr <= r.ptr; }
        friend constexpr bool operator>(const ptr32& l, const ptr32& r) { return l.ptr > r.ptr; }
        friend constexpr bool operator>=(const ptr32& l, const ptr32& r) { return l.ptr >= r.ptr; }

        template <typename ...Args>
        static ptr32 alloc(Args &&...args) {
            if (del.size()) {
                ptr32 ptr(del.back());
                del.pop_back();
                *ptr = object_type(std::forward<Args>(args)...);
                return ptr;
            } else {
                ptr32 ptr(pool.size());
                pool.emplace_back(std::forward<Args>(args)...);
                return ptr;
            }
        }
        static void dealloc(ptr32 p) {
            del.push_back(p);
        }
        static void dealloc_all(bool shrink) {
            pool.clear(), del.clear();
            if (shrink) pool.shrink_to_fit(), del.shrink_to_fit();
        }
        static void reserve(std::size_t capacity) {
            pool.reserve(capacity);
        }
    private:
        static inline pool_type pool{};
        static inline std::vector<ptr32> del{};

        int ptr;
    };
} // namespace suisen


#endif // SUISEN_32BIT_POINTER

#line 1 "library/util/pointer_32bit.hpp"



#include <vector>

namespace suisen {
    template <typename Object>
    struct ptr32 {
        static constexpr int null = -1;

        using object_type = Object;
        using pool_type = std::vector<object_type>;

        constexpr ptr32() : ptr(null) {}
        explicit constexpr ptr32(int ptr) : ptr(ptr) {}
        constexpr ptr32(std::nullptr_t) : ptr(null) {}

        object_type& operator*() const { return pool[ptr]; }
        object_type* operator->() const { return &pool[ptr]; }

        constexpr operator bool() const { return ptr != null; }
        constexpr operator int() const { return ptr; }

        constexpr bool is_not_null() const { return bool(*this); }
        constexpr bool is_null() const { return not bool(*this); }

        friend constexpr bool operator==(const ptr32& l, const ptr32& r) { return l.ptr == r.ptr; }
        friend constexpr bool operator!=(const ptr32& l, const ptr32& r) { return l.ptr != r.ptr; }
        friend constexpr bool operator<(const ptr32& l, const ptr32& r) { return l.ptr < r.ptr; }
        friend constexpr bool operator<=(const ptr32& l, const ptr32& r) { return l.ptr <= r.ptr; }
        friend constexpr bool operator>(const ptr32& l, const ptr32& r) { return l.ptr > r.ptr; }
        friend constexpr bool operator>=(const ptr32& l, const ptr32& r) { return l.ptr >= r.ptr; }

        template <typename ...Args>
        static ptr32 alloc(Args &&...args) {
            if (del.size()) {
                ptr32 ptr(del.back());
                del.pop_back();
                *ptr = object_type(std::forward<Args>(args)...);
                return ptr;
            } else {
                ptr32 ptr(pool.size());
                pool.emplace_back(std::forward<Args>(args)...);
                return ptr;
            }
        }
        static void dealloc(ptr32 p) {
            del.push_back(p);
        }
        static void dealloc_all(bool shrink) {
            pool.clear(), del.clear();
            if (shrink) pool.shrink_to_fit(), del.shrink_to_fit();
        }
        static void reserve(std::size_t capacity) {
            pool.reserve(capacity);
        }
    private:
        static inline pool_type pool{};
        static inline std::vector<ptr32> del{};

        int ptr;
    };
} // namespace suisen

Back to top page