An intrusive list node.A base class to enable membership in intrusive lists, including simple_ilist, iplist, and ilist. The first template parameter is the value_type for the list.
An ilist node can be configured with compile-time options to change behaviour and/or add API.
By default, an ilist_node knows whether it is the list sentinel (an instance of ilist_sentinel) if and only if LLVM_ENABLE_ABI_BREAKING_CHECKS. The function isKnownSentinel() always returns false
tracking is off. Sentinel tracking steals a bit from the "prev" link, which adds a mask operation when decrementing an iterator, but enables bug-finding assertions in ilist_iterator.
To turn sentinel tracking on all the time, pass in the ilist_sentinel_tracking<true> template parameter. This also enables the isSentinel() function. The same option must be passed to the intrusive list. (ilist_sentinel_tracking<false> turns sentinel tracking off all the time.)
A type can inherit from ilist_node multiple times by passing in different ilist_tag options. This allows a single instance to be inserted into multiple lists simultaneously, where each list is given the same tag.
struct A {}; struct B {}; struct N : ilist_node<N, ilist_tag>, ilist_node<N, ilist_tag> {};
void foo() { simple_ilist<N, ilist_tag> ListA; simple_ilist<N, ilist_tag> ListB; N N1; ListA.push_back(N1); ListB.push_back(N1); } \endexample
See is_valid_option for steps on adding a new option.
#ifndef LLVM_ADT_ILIST_NODE_H
#define LLVM_ADT_ILIST_NODE_H
namespace ilist_detail {
struct NodeAccess;
}
template <class OptionsT, bool IsReverse, bool IsConst> class ilist_iterator;
template <class OptionsT> class ilist_sentinel;
template <class OptionsT> class ilist_node_impl : OptionsT::node_base_type {
using value_type = typename OptionsT::value_type;
using node_base_type = typename OptionsT::node_base_type;
using list_base_type = typename OptionsT::list_base_type;
friend typename OptionsT::list_base_type;
friend class ilist_sentinel<OptionsT>;
friend class ilist_iterator<OptionsT,
false,
false>;
friend class ilist_iterator<OptionsT,
false,
true>;
friend class ilist_iterator<OptionsT,
true,
false>;
friend class ilist_iterator<OptionsT,
true,
true>;
protected:
private:
}
}
}
}
public:
}
}
using node_base_type::isKnownSentinel;
static_assert(OptionsT::is_sentinel_tracking_explicit,
"Use ilist_sentinel_tracking<true> to enable isSentinel()");
}
};
class ilist_node
: public ilist_node_impl<
typename ilist_detail::compute_node_options<T, Options...>::type> {
static_assert(ilist_detail::check_options<Options...>::value,
"Unrecognized node option!");
};
namespace ilist_detail {
struct NodeAccess {
protected:
template <class OptionsT>
}
template <class OptionsT>
static const ilist_node_impl<OptionsT> *
}
template <class OptionsT>
}
template <class OptionsT>
static typename OptionsT::const_pointer
return static_cast<typename OptionsT::const_pointer
>(
N);
}
template <class OptionsT>
static ilist_node_impl<OptionsT> *
getPrev(ilist_node_impl<OptionsT> &
N) {
}
template <class OptionsT>
static ilist_node_impl<OptionsT> *
getNext(ilist_node_impl<OptionsT> &
N) {
}
template <class OptionsT>
static const ilist_node_impl<OptionsT> *
getPrev(
const ilist_node_impl<OptionsT> &
N) {
}
template <class OptionsT>
static const ilist_node_impl<OptionsT> *
getNext(
const ilist_node_impl<OptionsT> &
N) {
}
};
template <class OptionsT> struct SpecificNodeAccess : NodeAccess {
protected:
return NodeAccess::getNodePtr<OptionsT>(
N);
}
return NodeAccess::getNodePtr<OptionsT>(
N);
}
return NodeAccess::getValuePtr<OptionsT>(
N);
}
return NodeAccess::getValuePtr<OptionsT>(
N);
}
};
}
template <class OptionsT>
class ilist_sentinel : public ilist_node_impl<OptionsT> {
public:
this->initializeSentinel();
}
this->setPrev(this);
this->setNext(this);
}
bool empty()
const {
return this == this->getPrev(); }
};
template <
typename NodeTy,
typename ParentTy,
class...
Options>
class ilist_node_with_parent : public ilist_node<NodeTy, Options...> {
protected:
private:
const ParentTy *getNodeParent() const {
return static_cast<const NodeTy *
>(
this)->
getParent();
}
public:
getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
return List.getPrevNode(*
static_cast<NodeTy *
>(
this));
}
}
getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
return List.getNextNode(*
static_cast<NodeTy *
>(
this));
}
}
};
}
#endif // LLVM_ADT_ILIST_NODE_H