view release on metacpan or  search on metacpan

src/panda/owning_list.h  view on Meta::CPAN

#pragma once
#include "refcnt.h"

namespace panda {
/**
 * owning_list where iterators share owning of nodes with list.
 * Removing of any iterator never invalidates value under it.
 * Forward iterator never invalidates, even if all list cleared.
 * Backward iterator keep valid value, but operator++ may lead to invalid iterator if no one keep reference to it
 * Removeing of element just fork list
 * 1 -> 2 -> 3
 * remove(2)
 * 1 -> 3
 *      ^
 *      2
 * Node will be deleted when all strong reference to it will be forgotten
 * Reference to previous node is weak
 * 1-> 2-> 3

src/panda/owning_list.h  view on Meta::CPAN

        bool operator !=(const base_iterator& oth) const {
            return !operator==(oth);
        }
    };

    using reverse_iterator = base_iterator<prev_strategy>;
    using iterator = base_iterator<next_strategy>;

    owning_list() : _size(0), first(nullptr), last(nullptr) {}
    ~owning_list() {
        clear(); // do not remove! we must invalidate all elements to make ++ on any iterator correct
    }

    iterator begin() {
        return first;
    }

    iterator end() {
        return iterator(nullptr);
    }

src/panda/refcnt.h  view on Meta::CPAN

        object = nullptr;
    }

    void swap(weak_iptr& oth) noexcept {
        storage.swap(oth.storage);
        std::swap(object, oth.object);
    }

private:
    iptr<weak_storage> storage;
    T* object; // it is cache, it never invalidates itself, use storage->object to check validity
};

template <class T>
void swap(weak_iptr<T>& a, weak_iptr<T>& b) noexcept { a.swap(b); }

template <class T> struct _weak_t;
template <class T> struct _weak_t<iptr<T>> {
    using type = weak_iptr<T>;
};