blender
/
blender
135
403
Fork 586
Code Issues 6.2k Pull Requests 758 Projects 19 Wiki Activity

Cleanup: Use trailing underscore for non-public data members 

This makes the code conform better with our style guide.
This commit is contained in:
Jacques Lucke 2020-07-03 14:15:05 +02:00
parent e797c4f28f
commit d64803f63b
26 changed files with 1238 additions and 1241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
source/blender/blenkernel/BKE_derived_node_tree.hh
View File

@ -45,9 +45,9 @@ class DerivedNodeTree;
class DSocket : NonCopyable, NonMovable {
protected:
DNode *m_node;
const SocketRef *m_socket_ref;
uint m_id;
DNode *node_;
const SocketRef *socket_ref_;
uint id_;
friend DerivedNodeTree;
@ -76,8 +76,8 @@ class DSocket : NonCopyable, NonMovable {
class DInputSocket : public DSocket {
private:
Vector<DOutputSocket *> m_linked_sockets;
Vector<DGroupInput *> m_linked_group_inputs;
Vector<DOutputSocket *> linked_sockets_;
Vector<DGroupInput *> linked_group_inputs_;
friend DerivedNodeTree;
@ -92,7 +92,7 @@ class DInputSocket : public DSocket {
class DOutputSocket : public DSocket {
private:
Vector<DInputSocket *> m_linked_sockets;
Vector<DInputSocket *> linked_sockets_;
friend DerivedNodeTree;
@ -103,10 +103,10 @@ class DOutputSocket : public DSocket {
class DGroupInput : NonCopyable, NonMovable {
private:
const InputSocketRef *m_socket_ref;
DParentNode *m_parent;
Vector<DInputSocket *> m_linked_sockets;
uint m_id;
const InputSocketRef *socket_ref_;
DParentNode *parent_;
Vector<DInputSocket *> linked_sockets_;
uint id_;
friend DerivedNodeTree;
@ -121,13 +121,13 @@ class DGroupInput : NonCopyable, NonMovable {
class DNode : NonCopyable, NonMovable {
private:
const NodeRef *m_node_ref;
DParentNode *m_parent;
const NodeRef *node_ref_;
DParentNode *parent_;
Span<DInputSocket *> m_inputs;
Span<DOutputSocket *> m_outputs;
Span<DInputSocket *> inputs_;
Span<DOutputSocket *> outputs_;
uint m_id;
uint id_;
friend DerivedNodeTree;
@ -153,9 +153,9 @@ class DNode : NonCopyable, NonMovable {
class DParentNode : NonCopyable, NonMovable {
private:
const NodeRef *m_node_ref;
DParentNode *m_parent;
uint m_id;
const NodeRef *node_ref_;
DParentNode *parent_;
uint id_;
friend DerivedNodeTree;
@ -169,17 +169,17 @@ using NodeTreeRefMap = Map<bNodeTree *, std::unique_ptr<const NodeTreeRef>>;
class DerivedNodeTree : NonCopyable, NonMovable {
private:
LinearAllocator<> m_allocator;
bNodeTree *m_btree;
Vector<DNode *> m_nodes_by_id;
Vector<DGroupInput *> m_group_inputs;
Vector<DParentNode *> m_parent_nodes;
LinearAllocator<> allocator_;
bNodeTree *btree_;
Vector<DNode *> nodes_by_id_;
Vector<DGroupInput *> group_inputs_;
Vector<DParentNode *> parent_nodes_;
Vector<DSocket *> m_sockets_by_id;
Vector<DInputSocket *> m_input_sockets;
Vector<DOutputSocket *> m_output_sockets;
Vector<DSocket *> sockets_by_id_;
Vector<DInputSocket *> input_sockets_;
Vector<DOutputSocket *> output_sockets_;
Map<const bNodeType *, Vector<DNode *>> m_nodes_by_type;
Map<const bNodeType *, Vector<DNode *>> nodes_by_type_;
public:
DerivedNodeTree(bNodeTree *btree, NodeTreeRefMap &node_tree_refs);
@ -235,27 +235,27 @@ class DerivedNodeTree : NonCopyable, NonMovable {
inline const DNode &DSocket::node() const
{
return *m_node;
return *node_;
}
inline uint DSocket::id() const
{
return m_id;
return id_;
}
inline uint DSocket::index() const
{
return m_socket_ref->index();
return socket_ref_->index();
}
inline bool DSocket::is_input() const
{
return m_socket_ref->is_input();
return socket_ref_->is_input();
}
inline bool DSocket::is_output() const
{
return m_socket_ref->is_output();
return socket_ref_->is_output();
}
inline const DSocket &DSocket::as_base() const
@ -275,32 +275,32 @@ inline const DOutputSocket &DSocket::as_output() const
inline PointerRNA *DSocket::rna() const
{
return m_socket_ref->rna();
return socket_ref_->rna();
}
inline StringRefNull DSocket::idname() const
{
return m_socket_ref->idname();
return socket_ref_->idname();
}
inline StringRefNull DSocket::name() const
{
return m_socket_ref->name();
return socket_ref_->name();
}
inline const SocketRef &DSocket::socket_ref() const
{
return *m_socket_ref;
return *socket_ref_;
}
inline bNodeSocket *DSocket::bsocket() const
{
return m_socket_ref->bsocket();
return socket_ref_->bsocket();
}
inline bool DSocket::is_available() const
{
return (m_socket_ref->bsocket()->flag & SOCK_UNAVAIL) == 0;
return (socket_ref_->bsocket()->flag & SOCK_UNAVAIL) == 0;
}
/* --------------------------------------------------------------------
@ -309,22 +309,22 @@ inline bool DSocket::is_available() const
inline const InputSocketRef &DInputSocket::socket_ref() const
{
return m_socket_ref->as_input();
return socket_ref_->as_input();
}
inline Span<const DOutputSocket *> DInputSocket::linked_sockets() const
{
return m_linked_sockets.as_span();
return linked_sockets_.as_span();
}
inline Span<const DGroupInput *> DInputSocket::linked_group_inputs() const
{
return m_linked_group_inputs.as_span();
return linked_group_inputs_.as_span();
}
inline bool DInputSocket::is_linked() const
{
return m_linked_sockets.size() > 0 || m_linked_group_inputs.size() > 0;
return linked_sockets_.size() > 0 || linked_group_inputs_.size() > 0;
}
/* --------------------------------------------------------------------
@ -333,12 +333,12 @@ inline bool DInputSocket::is_linked() const
inline const OutputSocketRef &DOutputSocket::socket_ref() const
{
return m_socket_ref->as_output();
return socket_ref_->as_output();
}
inline Span<const DInputSocket *> DOutputSocket::linked_sockets() const
{
return m_linked_sockets.as_span();
return linked_sockets_.as_span();
}
/* --------------------------------------------------------------------
@ -347,32 +347,32 @@ inline Span<const DInputSocket *> DOutputSocket::linked_sockets() const
inline const InputSocketRef &DGroupInput::socket_ref() const
{
return *m_socket_ref;
return *socket_ref_;
}
inline bNodeSocket *DGroupInput::bsocket() const
{
return m_socket_ref->bsocket();
return socket_ref_->bsocket();
}
inline const DParentNode *DGroupInput::parent() const
{
return m_parent;
return parent_;
}
inline Span<const DInputSocket *> DGroupInput::linked_sockets() const
{
return m_linked_sockets.as_span();
return linked_sockets_.as_span();
}
inline uint DGroupInput::id() const
{
return m_id;
return id_;
}
inline StringRefNull DGroupInput::name() const
{
return m_socket_ref->name();
return socket_ref_->name();
}
/* --------------------------------------------------------------------
@ -381,52 +381,52 @@ inline StringRefNull DGroupInput::name() const
inline const NodeRef &DNode::node_ref() const
{
return *m_node_ref;
return *node_ref_;
}
inline const DParentNode *DNode::parent() const
{
return m_parent;
return parent_;
}
inline Span<const DInputSocket *> DNode::inputs() const
{
return m_inputs;
return inputs_;
}
inline Span<const DOutputSocket *> DNode::outputs() const
{
return m_outputs;
return outputs_;
}
inline const DInputSocket &DNode::input(uint index) const
{
return *m_inputs[index];
return *inputs_[index];
}
inline const DOutputSocket &DNode::output(uint index) const
{
return *m_outputs[index];
return *outputs_[index];
}
inline uint DNode::id() const
{
return m_id;
return id_;
}
inline PointerRNA *DNode::rna() const
{
return m_node_ref->rna();
return node_ref_->rna();
}
inline StringRefNull DNode::idname() const
{
return m_node_ref->idname();
return node_ref_->idname();
}
inline StringRefNull DNode::name() const
{
return m_node_ref->name();
return node_ref_->name();
}
/* --------------------------------------------------------------------
@ -435,17 +435,17 @@ inline StringRefNull DNode::name() const
inline const DParentNode *DParentNode::parent() const
{
return m_parent;
return parent_;
}
inline const NodeRef &DParentNode::node_ref() const
{
return *m_node_ref;
return *node_ref_;
}
inline uint DParentNode::id() const
{
return m_id;
return id_;
}
/* --------------------------------------------------------------------
@ -454,7 +454,7 @@ inline uint DParentNode::id() const
inline Span<const DNode *> DerivedNodeTree::nodes() const
{
return m_nodes_by_id.as_span();
return nodes_by_id_.as_span();
}
inline Span<const DNode *> DerivedNodeTree::nodes_by_type(StringRefNull idname) const
@ -465,7 +465,7 @@ inline Span<const DNode *> DerivedNodeTree::nodes_by_type(StringRefNull idname)
inline Span<const DNode *> DerivedNodeTree::nodes_by_type(const bNodeType *nodetype) const
{
const Vector<DNode *> *nodes = m_nodes_by_type.lookup_ptr(nodetype);
const Vector<DNode *> *nodes = nodes_by_type_.lookup_ptr(nodetype);
if (nodes == nullptr) {
return {};
}
@ -476,22 +476,22 @@ inline Span<const DNode *> DerivedNodeTree::nodes_by_type(const bNodeType *nodet
inline Span<const DSocket *> DerivedNodeTree::sockets() const
{
return m_sockets_by_id.as_span();
return sockets_by_id_.as_span();
}
inline Span<const DInputSocket *> DerivedNodeTree::input_sockets() const
{
return m_input_sockets.as_span();
return input_sockets_.as_span();
}
inline Span<const DOutputSocket *> DerivedNodeTree::output_sockets() const
{
return m_output_sockets.as_span();
return output_sockets_.as_span();
}
inline Span<const DGroupInput *> DerivedNodeTree::group_inputs() const
{
return m_group_inputs.as_span();
return group_inputs_.as_span();
}
} // namespace bke

122
source/blender/blenkernel/BKE_node_tree_ref.hh
View File

@ -69,14 +69,14 @@ class NodeTreeRef;
class SocketRef : NonCopyable, NonMovable {
protected:
NodeRef *m_node;
bNodeSocket *m_bsocket;
bool m_is_input;
uint m_id;
uint m_index;
PointerRNA m_rna;
Vector<SocketRef *> m_linked_sockets;
Vector<SocketRef *> m_directly_linked_sockets;
NodeRef *node_;
bNodeSocket *bsocket_;
bool is_input_;
uint id_;
uint index_;
PointerRNA rna_;
Vector<SocketRef *> linked_sockets_;
Vector<SocketRef *> directly_linked_sockets_;
friend NodeTreeRef;
@ -122,12 +122,12 @@ class OutputSocketRef final : public SocketRef {
class NodeRef : NonCopyable, NonMovable {
private:
NodeTreeRef *m_tree;
bNode *m_bnode;
PointerRNA m_rna;
uint m_id;
Vector<InputSocketRef *> m_inputs;
Vector<OutputSocketRef *> m_outputs;
NodeTreeRef *tree_;
bNode *bnode_;
PointerRNA rna_;
uint id_;
Vector<InputSocketRef *> inputs_;
Vector<OutputSocketRef *> outputs_;
friend NodeTreeRef;
@ -157,13 +157,13 @@ class NodeRef : NonCopyable, NonMovable {
class NodeTreeRef : NonCopyable, NonMovable {
private:
LinearAllocator<> m_allocator;
bNodeTree *m_btree;
Vector<NodeRef *> m_nodes_by_id;
Vector<SocketRef *> m_sockets_by_id;
Vector<InputSocketRef *> m_input_sockets;
Vector<OutputSocketRef *> m_output_sockets;
Map<const bNodeType *, Vector<NodeRef *>> m_nodes_by_type;
LinearAllocator<> allocator_;
bNodeTree *btree_;
Vector<NodeRef *> nodes_by_id_;
Vector<SocketRef *> sockets_by_id_;
Vector<InputSocketRef *> input_sockets_;
Vector<OutputSocketRef *> output_sockets_;
Map<const bNodeType *, Vector<NodeRef *>> nodes_by_type_;
public:
NodeTreeRef(bNodeTree *btree);
@ -198,47 +198,47 @@ class NodeTreeRef : NonCopyable, NonMovable {
inline Span<const SocketRef *> SocketRef::linked_sockets() const
{
return m_linked_sockets.as_span();
return linked_sockets_.as_span();
}
inline Span<const SocketRef *> SocketRef::directly_linked_sockets() const
{
return m_directly_linked_sockets.as_span();
return directly_linked_sockets_.as_span();
}
inline bool SocketRef::is_linked() const
{
return m_linked_sockets.size() > 0;
return linked_sockets_.size() > 0;
}
inline const NodeRef &SocketRef::node() const
{
return *m_node;
return *node_;
}
inline const NodeTreeRef &SocketRef::tree() const
{
return m_node->tree();
return node_->tree();
}
inline uint SocketRef::id() const
{
return m_id;
return id_;
}
inline uint SocketRef::index() const
{
return m_index;
return index_;
}
inline bool SocketRef::is_input() const
{
return m_is_input;
return is_input_;
}
inline bool SocketRef::is_output() const
{
return !m_is_input;
return !is_input_;
}
inline const SocketRef &SocketRef::as_base() const
@ -260,32 +260,32 @@ inline const OutputSocketRef &SocketRef::as_output() const
inline PointerRNA *SocketRef::rna() const
{
return const_cast<PointerRNA *>(&m_rna);
return const_cast<PointerRNA *>(&rna_);
}
inline StringRefNull SocketRef::idname() const
{
return m_bsocket->idname;
return bsocket_->idname;
}
inline StringRefNull SocketRef::name() const
{
return m_bsocket->name;
return bsocket_->name;
}
inline bNodeSocket *SocketRef::bsocket() const
{
return m_bsocket;
return bsocket_;
}
inline bNode *SocketRef::bnode() const
{
return m_node->bnode();
return node_->bnode();
}
inline bNodeTree *SocketRef::btree() const
{
return m_node->btree();
return node_->btree();
}
/* --------------------------------------------------------------------
@ -294,12 +294,12 @@ inline bNodeTree *SocketRef::btree() const
inline Span<const OutputSocketRef *> InputSocketRef::linked_sockets() const
{
return m_linked_sockets.as_span().cast<const OutputSocketRef *>();
return linked_sockets_.as_span().cast<const OutputSocketRef *>();
}
inline Span<const OutputSocketRef *> InputSocketRef::directly_linked_sockets() const
{
return m_directly_linked_sockets.as_span().cast<const OutputSocketRef *>();
return directly_linked_sockets_.as_span().cast<const OutputSocketRef *>();
}
/* --------------------------------------------------------------------
@ -308,12 +308,12 @@ inline Span<const OutputSocketRef *> InputSocketRef::directly_linked_sockets() c
inline Span<const InputSocketRef *> OutputSocketRef::linked_sockets() const
{
return m_linked_sockets.as_span().cast<const InputSocketRef *>();
return linked_sockets_.as_span().cast<const InputSocketRef *>();
}
inline Span<const InputSocketRef *> OutputSocketRef::directly_linked_sockets() const
{
return m_directly_linked_sockets.as_span().cast<const InputSocketRef *>();
return directly_linked_sockets_.as_span().cast<const InputSocketRef *>();
}
/* --------------------------------------------------------------------
@ -322,77 +322,77 @@ inline Span<const InputSocketRef *> OutputSocketRef::directly_linked_sockets() c
inline const NodeTreeRef &NodeRef::tree() const
{
return *m_tree;
return *tree_;
}
inline Span<const InputSocketRef *> NodeRef::inputs() const
{
return m_inputs.as_span();
return inputs_.as_span();
}
inline Span<const OutputSocketRef *> NodeRef::outputs() const
{
return m_outputs.as_span();
return outputs_.as_span();
}
inline const InputSocketRef &NodeRef::input(uint index) const
{
return *m_inputs[index];
return *inputs_[index];
}
inline const OutputSocketRef &NodeRef::output(uint index) const
{
return *m_outputs[index];
return *outputs_[index];
}
inline bNode *NodeRef::bnode() const
{
return m_bnode;
return bnode_;
}
inline bNodeTree *NodeRef::btree() const
{
return m_tree->btree();
return tree_->btree();
}
inline PointerRNA *NodeRef::rna() const
{
return const_cast<PointerRNA *>(&m_rna);
return const_cast<PointerRNA *>(&rna_);
}
inline StringRefNull NodeRef::idname() const
{
return m_bnode->idname;
return bnode_->idname;
}
inline StringRefNull NodeRef::name() const
{
return m_bnode->name;
return bnode_->name;
}
inline uint NodeRef::id() const
{
return m_id;
return id_;
}
inline bool NodeRef::is_reroute_node() const
{
return m_bnode->type == NODE_REROUTE;
return bnode_->type == NODE_REROUTE;
}
inline bool NodeRef::is_group_node() const
{
return m_bnode->type == NODE_GROUP;
return bnode_->type == NODE_GROUP;
}
inline bool NodeRef::is_group_input_node() const
{
return m_bnode->type == NODE_GROUP_INPUT;
return bnode_->type == NODE_GROUP_INPUT;
}
inline bool NodeRef::is_group_output_node() const
{
return m_bnode->type == NODE_GROUP_OUTPUT;
return bnode_->type == NODE_GROUP_OUTPUT;
}
/* --------------------------------------------------------------------
@ -401,7 +401,7 @@ inline bool NodeRef::is_group_output_node() const
inline Span<const NodeRef *> NodeTreeRef::nodes() const
{
return m_nodes_by_id.as_span();
return nodes_by_id_.as_span();
}
inline Span<const NodeRef *> NodeTreeRef::nodes_by_type(StringRefNull idname) const
@ -412,7 +412,7 @@ inline Span<const NodeRef *> NodeTreeRef::nodes_by_type(StringRefNull idname) co
inline Span<const NodeRef *> NodeTreeRef::nodes_by_type(const bNodeType *nodetype) const
{
const Vector<NodeRef *> *nodes = m_nodes_by_type.lookup_ptr(nodetype);
const Vector<NodeRef *> *nodes = nodes_by_type_.lookup_ptr(nodetype);
if (nodes == nullptr) {
return {};
}
@ -423,22 +423,22 @@ inline Span<const NodeRef *> NodeTreeRef::nodes_by_type(const bNodeType *nodetyp
inline Span<const SocketRef *> NodeTreeRef::sockets() const
{
return m_sockets_by_id.as_span();
return sockets_by_id_.as_span();
}
inline Span<const InputSocketRef *> NodeTreeRef::input_sockets() const
{
return m_input_sockets.as_span();
return input_sockets_.as_span();
}
inline Span<const OutputSocketRef *> NodeTreeRef::output_sockets() const
{
return m_output_sockets.as_span();
return output_sockets_.as_span();
}
inline bNodeTree *NodeTreeRef::btree() const
{
return m_btree;
return btree_;
}
} // namespace bke

188
source/blender/blenkernel/intern/derived_node_tree.cc
View File

@ -29,7 +29,7 @@ static const NodeTreeRef &get_tree_ref(NodeTreeRefMap &node_tree_refs, bNodeTree
[&]() { return std::make_unique<NodeTreeRef>(btree); });
}
DerivedNodeTree::DerivedNodeTree(bNodeTree *btree, NodeTreeRefMap &node_tree_refs) : m_btree(btree)
DerivedNodeTree::DerivedNodeTree(bNodeTree *btree, NodeTreeRefMap &node_tree_refs) : btree_(btree)
{
const NodeTreeRef &main_tree_ref = get_tree_ref(node_tree_refs, btree);
@ -63,8 +63,8 @@ BLI_NOINLINE void DerivedNodeTree::insert_nodes_and_links_in_id_order(const Node
DInputSocket *to_socket = (DInputSocket *)sockets_map[to_socket_ref->id()];
for (const OutputSocketRef *from_socket_ref : to_socket_ref->linked_sockets()) {
DOutputSocket *from_socket = (DOutputSocket *)sockets_map[from_socket_ref->id()];
to_socket->m_linked_sockets.append(from_socket);
from_socket->m_linked_sockets.append(to_socket);
to_socket->linked_sockets_.append(from_socket);
from_socket->linked_sockets_.append(to_socket);
}
}
}
@ -74,34 +74,34 @@ DNode &DerivedNodeTree::create_node(const NodeRef &node_ref,
DParentNode *parent,
MutableSpan<DSocket *> r_sockets_map)
{
DNode &node = *m_allocator.construct<DNode>();
node.m_node_ref = &node_ref;
node.m_parent = parent;
node.m_id = UNINITIALIZED_ID;
DNode &node = *allocator_.construct<DNode>();
node.node_ref_ = &node_ref;
node.parent_ = parent;
node.id_ = UNINITIALIZED_ID;
node.m_inputs = m_allocator.construct_elements_and_pointer_array<DInputSocket>(
node.inputs_ = allocator_.construct_elements_and_pointer_array<DInputSocket>(
node_ref.inputs().size());
node.m_outputs = m_allocator.construct_elements_and_pointer_array<DOutputSocket>(
node.outputs_ = allocator_.construct_elements_and_pointer_array<DOutputSocket>(
node_ref.outputs().size());
for (uint i : node.m_inputs.index_range()) {
for (uint i : node.inputs_.index_range()) {
const InputSocketRef &socket_ref = node_ref.input(i);
DInputSocket &socket = *node.m_inputs[i];
DInputSocket &socket = *node.inputs_[i];
socket.m_id = UNINITIALIZED_ID;
socket.m_node = &node;
socket.m_socket_ref = &socket_ref;
socket.id_ = UNINITIALIZED_ID;
socket.node_ = &node;
socket.socket_ref_ = &socket_ref;
r_sockets_map[socket_ref.id()] = &socket;
}
for (uint i : node.m_outputs.index_range()) {
for (uint i : node.outputs_.index_range()) {
const OutputSocketRef &socket_ref = node_ref.output(i);
DOutputSocket &socket = *node.m_outputs[i];
DOutputSocket &socket = *node.outputs_[i];
socket.m_id = UNINITIALIZED_ID;
socket.m_node = &node;
socket.m_socket_ref = &socket_ref;
socket.id_ = UNINITIALIZED_ID;
socket.node_ = &node;
socket.socket_ref_ = &socket_ref;
r_sockets_map[socket_ref.id()] = &socket;
}
@ -116,7 +116,7 @@ BLI_NOINLINE void DerivedNodeTree::expand_groups(Vector<DNode *> &all_nodes,
{
for (uint i = 0; i < all_nodes.size(); i++) {
DNode &node = *all_nodes[i];
if (node.m_node_ref->is_group_node()) {
if (node.node_ref_->is_group_node()) {
this->expand_group_node(node, all_nodes, all_group_inputs, all_parent_nodes, node_tree_refs);
}
}
@ -128,7 +128,7 @@ BLI_NOINLINE void DerivedNodeTree::expand_group_node(DNode &group_node,
Vector<DParentNode *> &all_parent_nodes,
NodeTreeRefMap &node_tree_refs)
{
const NodeRef &group_node_ref = *group_node.m_node_ref;
const NodeRef &group_node_ref = *group_node.node_ref_;
BLI_assert(group_node_ref.is_group_node());
bNodeTree *btree = (bNodeTree *)group_node_ref.bnode()->id;
@ -138,10 +138,10 @@ BLI_NOINLINE void DerivedNodeTree::expand_group_node(DNode &group_node,
const NodeTreeRef &group_ref = get_tree_ref(node_tree_refs, btree);
DParentNode &parent = *m_allocator.construct<DParentNode>();
parent.m_id = all_parent_nodes.append_and_get_index(&parent);
parent.m_parent = group_node.m_parent;
parent.m_node_ref = &group_node_ref;
DParentNode &parent = *allocator_.construct<DParentNode>();
parent.id_ = all_parent_nodes.append_and_get_index(&parent);
parent.parent_ = group_node.parent_;
parent.node_ref_ = &group_node_ref;
this->insert_nodes_and_links_in_id_order(group_ref, &parent, all_nodes);
Span<DNode *> new_nodes_by_id = all_nodes.as_span().take_back(group_ref.nodes().size());
@ -154,18 +154,18 @@ BLI_NOINLINE void DerivedNodeTree::expand_group_node(DNode &group_node,
BLI_NOINLINE void DerivedNodeTree::create_group_inputs_for_unlinked_inputs(
DNode &node, Vector<DGroupInput *> &all_group_inputs)
{
for (DInputSocket *input_socket : node.m_inputs) {
for (DInputSocket *input_socket : node.inputs_) {
if (input_socket->is_linked()) {
continue;
}
DGroupInput &group_input = *m_allocator.construct<DGroupInput>();
group_input.m_id = UNINITIALIZED_ID;
group_input.m_socket_ref = &input_socket->socket_ref();
group_input.m_parent = node.m_parent;
DGroupInput &group_input = *allocator_.construct<DGroupInput>();
group_input.id_ = UNINITIALIZED_ID;
group_input.socket_ref_ = &input_socket->socket_ref();
group_input.parent_ = node.parent_;
group_input.m_linked_sockets.append(input_socket);
input_socket->m_linked_group_inputs.append(&group_input);
group_input.linked_sockets_.append(input_socket);
input_socket->linked_group_inputs_.append(&group_input);
all_group_inputs.append(&group_input);
}
}
@ -186,34 +186,34 @@ BLI_NOINLINE void DerivedNodeTree::relink_group_inputs(const NodeTreeRef &group_
BLI_assert(input_amount == input_node_ref.outputs().size() - 1);
for (uint input_index : IndexRange(input_amount)) {
DInputSocket *outside_group = group_node.m_inputs[input_index];
DOutputSocket *inside_group = input_node.m_outputs[input_index];
DInputSocket *outside_group = group_node.inputs_[input_index];
DOutputSocket *inside_group = input_node.outputs_[input_index];
for (DOutputSocket *outside_connected : outside_group->m_linked_sockets) {
outside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(outside_group);
for (DOutputSocket *outside_connected : outside_group->linked_sockets_) {
outside_connected->linked_sockets_.remove_first_occurrence_and_reorder(outside_group);
}
for (DGroupInput *outside_connected : outside_group->m_linked_group_inputs) {
outside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(outside_group);
for (DGroupInput *outside_connected : outside_group->linked_group_inputs_) {
outside_connected->linked_sockets_.remove_first_occurrence_and_reorder(outside_group);
}
for (DInputSocket *inside_connected : inside_group->m_linked_sockets) {
inside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(inside_group);
for (DInputSocket *inside_connected : inside_group->linked_sockets_) {
inside_connected->linked_sockets_.remove_first_occurrence_and_reorder(inside_group);
for (DOutputSocket *outside_connected : outside_group->m_linked_sockets) {
inside_connected->m_linked_sockets.append(outside_connected);
outside_connected->m_linked_sockets.append(inside_connected);
for (DOutputSocket *outside_connected : outside_group->linked_sockets_) {
inside_connected->linked_sockets_.append(outside_connected);
outside_connected->linked_sockets_.append(inside_connected);
}
for (DGroupInput *outside_connected : outside_group->m_linked_group_inputs) {
inside_connected->m_linked_group_inputs.append(outside_connected);
outside_connected->m_linked_sockets.append(inside_connected);
for (DGroupInput *outside_connected : outside_group->linked_group_inputs_) {
inside_connected->linked_group_inputs_.append(outside_connected);
outside_connected->linked_sockets_.append(inside_connected);
}
}
inside_group->m_linked_sockets.clear();
outside_group->m_linked_sockets.clear();
outside_group->m_linked_group_inputs.clear();
inside_group->linked_sockets_.clear();
outside_group->linked_sockets_.clear();
outside_group->linked_group_inputs_.clear();
}
}
@ -233,33 +233,33 @@ BLI_NOINLINE void DerivedNodeTree::relink_group_outputs(const NodeTreeRef &group
BLI_assert(output_amount == output_node_ref.inputs().size() - 1);
for (uint output_index : IndexRange(output_amount)) {
DOutputSocket *outside_group = group_node.m_outputs[output_index];
DInputSocket *inside_group = output_node.m_inputs[output_index];
DOutputSocket *outside_group = group_node.outputs_[output_index];
DInputSocket *inside_group = output_node.inputs_[output_index];
for (DInputSocket *outside_connected : outside_group->m_linked_sockets) {
outside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(outside_group);
for (DInputSocket *outside_connected : outside_group->linked_sockets_) {
outside_connected->linked_sockets_.remove_first_occurrence_and_reorder(outside_group);
}
for (DOutputSocket *inside_connected : inside_group->m_linked_sockets) {
inside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(inside_group);
for (DOutputSocket *inside_connected : inside_group->linked_sockets_) {
inside_connected->linked_sockets_.remove_first_occurrence_and_reorder(inside_group);
for (DInputSocket *outside_connected : outside_group->m_linked_sockets) {
inside_connected->m_linked_sockets.append(outside_connected);
outside_connected->m_linked_sockets.append(inside_connected);
for (DInputSocket *outside_connected : outside_group->linked_sockets_) {
inside_connected->linked_sockets_.append(outside_connected);
outside_connected->linked_sockets_.append(inside_connected);
}
}
for (DGroupInput *inside_connected : inside_group->m_linked_group_inputs) {
inside_connected->m_linked_sockets.remove_first_occurrence_and_reorder(inside_group);
for (DGroupInput *inside_connected : inside_group->linked_group_inputs_) {
inside_connected->linked_sockets_.remove_first_occurrence_and_reorder(inside_group);
for (DInputSocket *outside_connected : outside_group->m_linked_sockets) {
inside_connected->m_linked_sockets.append(outside_connected);
outside_connected->m_linked_group_inputs.append(inside_connected);
for (DInputSocket *outside_connected : outside_group->linked_sockets_) {
inside_connected->linked_sockets_.append(outside_connected);
outside_connected->linked_group_inputs_.append(inside_connected);
}
}
outside_group->m_linked_sockets.clear();
inside_group->m_linked_sockets.clear();
outside_group->linked_sockets_.clear();
inside_group->linked_sockets_.clear();
}
}
@ -268,9 +268,9 @@ BLI_NOINLINE void DerivedNodeTree::remove_expanded_group_interfaces(Vector<DNode
int index = 0;
while (index < all_nodes.size()) {
DNode &node = *all_nodes[index];
const NodeRef &node_ref = *node.m_node_ref;
const NodeRef &node_ref = *node.node_ref_;
if (node_ref.is_group_node() ||
(node.m_parent != nullptr &&
(node.parent_ != nullptr &&
(node_ref.is_group_input_node() || node_ref.is_group_output_node()))) {
all_nodes.remove_and_reorder(index);
node.destruct_with_sockets();
@ -287,7 +287,7 @@ BLI_NOINLINE void DerivedNodeTree::remove_unused_group_inputs(
int index = 0;
while (index < all_group_inputs.size()) {
DGroupInput &group_input = *all_group_inputs[index];
if (group_input.m_linked_sockets.is_empty()) {
if (group_input.linked_sockets_.is_empty()) {
all_group_inputs.remove_and_reorder(index);
group_input.~DGroupInput();
}
@ -299,10 +299,10 @@ BLI_NOINLINE void DerivedNodeTree::remove_unused_group_inputs(
void DNode::destruct_with_sockets()
{
for (DInputSocket *socket : m_inputs) {
for (DInputSocket *socket : inputs_) {
socket->~DInputSocket();
}
for (DOutputSocket *socket : m_outputs) {
for (DOutputSocket *socket : outputs_) {
socket->~DOutputSocket();
}
this->~DNode();
@ -313,47 +313,47 @@ BLI_NOINLINE void DerivedNodeTree::store_in_this_and_init_ids(
Vector<DGroupInput *> &&all_group_inputs,
Vector<DParentNode *> &&all_parent_nodes)
{
m_nodes_by_id = std::move(all_nodes);
m_group_inputs = std::move(all_group_inputs);
m_parent_nodes = std::move(all_parent_nodes);
nodes_by_id_ = std::move(all_nodes);
group_inputs_ = std::move(all_group_inputs);
parent_nodes_ = std::move(all_parent_nodes);
for (uint node_index : m_nodes_by_id.index_range()) {
DNode *node = m_nodes_by_id[node_index];
node->m_id = node_index;
for (uint node_index : nodes_by_id_.index_range()) {
DNode *node = nodes_by_id_[node_index];
node->id_ = node_index;
const bNodeType *nodetype = node->m_node_ref->bnode()->typeinfo;
m_nodes_by_type.lookup_or_add_default(nodetype).append(node);
const bNodeType *nodetype = node->node_ref_->bnode()->typeinfo;
nodes_by_type_.lookup_or_add_default(nodetype).append(node);
for (DInputSocket *socket : node->m_inputs) {
socket->m_id = m_sockets_by_id.append_and_get_index(socket);
m_input_sockets.append(socket);
for (DInputSocket *socket : node->inputs_) {
socket->id_ = sockets_by_id_.append_and_get_index(socket);
input_sockets_.append(socket);
}
for (DOutputSocket *socket : node->m_outputs) {
socket->m_id = m_sockets_by_id.append_and_get_index(socket);
m_output_sockets.append(socket);
for (DOutputSocket *socket : node->outputs_) {
socket->id_ = sockets_by_id_.append_and_get_index(socket);
output_sockets_.append(socket);
}
}
for (uint i : m_group_inputs.index_range()) {
m_group_inputs[i]->m_id = i;
for (uint i : group_inputs_.index_range()) {
group_inputs_[i]->id_ = i;
}
}
DerivedNodeTree::~DerivedNodeTree()
{
for (DInputSocket *socket : m_input_sockets) {
for (DInputSocket *socket : input_sockets_) {
socket->~DInputSocket();
}
for (DOutputSocket *socket : m_output_sockets) {
for (DOutputSocket *socket : output_sockets_) {
socket->~DOutputSocket();
}
for (DNode *node : m_nodes_by_id) {
for (DNode *node : nodes_by_id_) {
node->~DNode();
}
for (DGroupInput *group_input : m_group_inputs) {
for (DGroupInput *group_input : group_inputs_) {
group_input->~DGroupInput();
}
for (DParentNode *parent : m_parent_nodes) {
for (DParentNode *parent : parent_nodes_) {
parent->~DParentNode();
}
}
@ -384,7 +384,7 @@ std::string DerivedNodeTree::to_dot() const
Map<const DGroupInput *, dot::NodeWithSocketsRef> dot_group_inputs;
Map<const DParentNode *, dot::Cluster *> dot_clusters;
for (const DNode *node : m_nodes_by_id) {
for (const DNode *node : nodes_by_id_) {
dot::Node &dot_node = digraph.new_node("");
dot_node.set_background_color("white");
@ -404,7 +404,7 @@ std::string DerivedNodeTree::to_dot() const
dot_node.set_parent_cluster(cluster);
}
for (const DGroupInput *group_input : m_group_inputs) {
for (const DGroupInput *group_input : group_inputs_) {
dot::Node &dot_node = digraph.new_node("");
dot_node.set_background_color("white");
@ -416,7 +416,7 @@ std::string DerivedNodeTree::to_dot() const
dot_node.set_parent_cluster(cluster);
}
for (const DNode *to_node : m_nodes_by_id) {
for (const DNode *to_node : nodes_by_id_) {
dot::NodeWithSocketsRef &to_dot_node = dot_nodes.lookup(to_node);
for (const DInputSocket *to_socket : to_node->inputs()) {

92
source/blender/blenkernel/intern/node_tree_ref.cc
View File

@ -21,40 +21,40 @@
namespace blender {
namespace bke {
NodeTreeRef::NodeTreeRef(bNodeTree *btree) : m_btree(btree)
NodeTreeRef::NodeTreeRef(bNodeTree *btree) : btree_(btree)
{
Map<bNode *, NodeRef *> node_mapping;
LISTBASE_FOREACH (bNode *, bnode, &btree->nodes) {
NodeRef &node = *m_allocator.construct<NodeRef>();
NodeRef &node = *allocator_.construct<NodeRef>();
node.m_tree = this;
node.m_bnode = bnode;
node.m_id = m_nodes_by_id.append_and_get_index(&node);
RNA_pointer_create(&btree->id, &RNA_Node, bnode, &node.m_rna);
node.tree_ = this;
node.bnode_ = bnode;
node.id_ = nodes_by_id_.append_and_get_index(&node);
RNA_pointer_create(&btree->id, &RNA_Node, bnode, &node.rna_);
LISTBASE_FOREACH (bNodeSocket *, bsocket, &bnode->inputs) {
InputSocketRef &socket = *m_allocator.construct<InputSocketRef>();
socket.m_node = &node;
socket.m_index = node.m_inputs.append_and_get_index(&socket);
socket.m_is_input = true;
socket.m_bsocket = bsocket;
socket.m_id = m_sockets_by_id.append_and_get_index(&socket);
RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.m_rna);
InputSocketRef &socket = *allocator_.construct<InputSocketRef>();
socket.node_ = &node;
socket.index_ = node.inputs_.append_and_get_index(&socket);
socket.is_input_ = true;
socket.bsocket_ = bsocket;
socket.id_ = sockets_by_id_.append_and_get_index(&socket);
RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.rna_);
}
LISTBASE_FOREACH (bNodeSocket *, bsocket, &bnode->outputs) {
OutputSocketRef &socket = *m_allocator.construct<OutputSocketRef>();
socket.m_node = &node;
socket.m_index = node.m_outputs.append_and_get_index(&socket);
socket.m_is_input = false;
socket.m_bsocket = bsocket;
socket.m_id = m_sockets_by_id.append_and_get_index(&socket);
RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.m_rna);
OutputSocketRef &socket = *allocator_.construct<OutputSocketRef>();
socket.node_ = &node;
socket.index_ = node.outputs_.append_and_get_index(&socket);
socket.is_input_ = false;
socket.bsocket_ = bsocket;
socket.id_ = sockets_by_id_.append_and_get_index(&socket);
RNA_pointer_create(&btree->id, &RNA_NodeSocket, bsocket, &socket.rna_);
}
m_input_sockets.extend(node.m_inputs);
m_output_sockets.extend(node.m_outputs);
input_sockets_.extend(node.inputs_);
output_sockets_.extend(node.outputs_);
node_mapping.add_new(bnode, &node);
}
@ -65,34 +65,34 @@ NodeTreeRef::NodeTreeRef(bNodeTree *btree) : m_btree(btree)
InputSocketRef &to_socket = this->find_input_socket(
node_mapping, blink->tonode, blink->tosock);
from_socket.m_directly_linked_sockets.append(&to_socket);
to_socket.m_directly_linked_sockets.append(&from_socket);
from_socket.directly_linked_sockets_.append(&to_socket);
to_socket.directly_linked_sockets_.append(&from_socket);
}
for (OutputSocketRef *socket : m_output_sockets) {
if (!socket->m_node->is_reroute_node()) {
this->find_targets_skipping_reroutes(*socket, socket->m_linked_sockets);
for (SocketRef *target : socket->m_linked_sockets) {
target->m_linked_sockets.append(socket);
for (OutputSocketRef *socket : output_sockets_) {
if (!socket->node_->is_reroute_node()) {
this->find_targets_skipping_reroutes(*socket, socket->linked_sockets_);
for (SocketRef *target : socket->linked_sockets_) {
target->linked_sockets_.append(socket);
}
}
}
for (NodeRef *node : m_nodes_by_id) {
const bNodeType *nodetype = node->m_bnode->typeinfo;
m_nodes_by_type.lookup_or_add_default(nodetype).append(node);
for (NodeRef *node : nodes_by_id_) {
const bNodeType *nodetype = node->bnode_->typeinfo;
nodes_by_type_.lookup_or_add_default(nodetype).append(node);
}
}
NodeTreeRef::~NodeTreeRef()
{
for (NodeRef *node : m_nodes_by_id) {
for (NodeRef *node : nodes_by_id_) {
node->~NodeRef();
}
for (InputSocketRef *socket : m_input_sockets) {
for (InputSocketRef *socket : input_sockets_) {
socket->~InputSocketRef();
}
for (OutputSocketRef *socket : m_output_sockets) {
for (OutputSocketRef *socket : output_sockets_) {
socket->~OutputSocketRef();
}
}
@ -102,13 +102,13 @@ InputSocketRef &NodeTreeRef::find_input_socket(Map<bNode *, NodeRef *> &node_map
bNodeSocket *bsocket)
{
NodeRef *node = node_mapping.lookup(bnode);
for (SocketRef *socket : node->m_inputs) {
if (socket->m_bsocket == bsocket) {
for (SocketRef *socket : node->inputs_) {
if (socket->bsocket_ == bsocket) {
return *(InputSocketRef *)socket;
}
}
BLI_assert(false);
return *node->m_inputs[0];
return *node->inputs_[0];
}
OutputSocketRef &NodeTreeRef::find_output_socket(Map<bNode *, NodeRef *> &node_mapping,
@ -116,21 +116,21 @@ OutputSocketRef &NodeTreeRef::find_output_socket(Map<bNode *, NodeRef *> &node_m
bNodeSocket *bsocket)
{
NodeRef *node = node_mapping.lookup(bnode);
for (SocketRef *socket : node->m_outputs) {
if (socket->m_bsocket == bsocket) {
for (SocketRef *socket : node->outputs_) {
if (socket->bsocket_ == bsocket) {
return *(OutputSocketRef *)socket;
}
}
BLI_assert(false);
return *node->m_outputs[0];
return *node->outputs_[0];
}
void NodeTreeRef::find_targets_skipping_reroutes(OutputSocketRef &socket,
Vector<SocketRef *> &r_targets)
{
for (SocketRef *direct_target : socket.m_directly_linked_sockets) {
if (direct_target->m_node->is_reroute_node()) {
this->find_targets_skipping_reroutes(*direct_target->m_node->m_outputs[0], r_targets);
for (SocketRef *direct_target : socket.directly_linked_sockets_) {
if (direct_target->node_->is_reroute_node()) {
this->find_targets_skipping_reroutes(*direct_target->node_->outputs_[0], r_targets);
}
else {
r_targets.append_non_duplicates(direct_target);
@ -145,7 +145,7 @@ std::string NodeTreeRef::to_dot() const
Map<const NodeRef *, dot::NodeWithSocketsRef> dot_nodes;
for (const NodeRef *node : m_nodes_by_id) {
for (const NodeRef *node : nodes_by_id_) {
dot::Node &dot_node = digraph.new_node("");
dot_node.set_background_color("white");
@ -162,7 +162,7 @@ std::string NodeTreeRef::to_dot() const
dot::NodeWithSocketsRef(dot_node, node->name(), input_names, output_names));
}
for (const OutputSocketRef *from_socket : m_output_sockets) {
for (const OutputSocketRef *from_socket : output_sockets_) {
for (const InputSocketRef *to_socket : from_socket->directly_linked_sockets()) {
dot::NodeWithSocketsRef &from_dot_node = dot_nodes.lookup(&from_socket->node());
dot::NodeWithSocketsRef &to_dot_node = dot_nodes.lookup(&to_socket->node());

102
source/blender/blenlib/BLI_array.hh
View File

@ -65,16 +65,16 @@ template<
class Array {
private:
/** The beginning of the array. It might point into the inline buffer. */
T *m_data;
T *data_;
/** Number of elements in the array. */
uint m_size;
uint size_;
/** Used for allocations when the inline buffer is too small. */
Allocator m_allocator;
Allocator allocator_;
/** A placeholder buffer that will remain uninitialized until it is used. */
AlignedBuffer<sizeof(T) * InlineBufferCapacity, alignof(T)> m_inline_buffer;
AlignedBuffer<sizeof(T) * InlineBufferCapacity, alignof(T)> inline_buffer_;
public:
/**
@ -82,8 +82,8 @@ class Array {
*/
Array()
{
m_data = this->inline_buffer();
m_size = 0;
data_ = this->inline_buffer();
size_ = 0;
}
/**
@ -91,9 +91,9 @@ class Array {
*/
Array(Span<T> values)
{
m_size = values.size();
m_data = this->get_buffer_for_size(values.size());
uninitialized_copy_n(values.data(), m_size, m_data);
size_ = values.size();
data_ = this->get_buffer_for_size(values.size());
uninitialized_copy_n(values.data(), size_, data_);
}
/**
@ -113,9 +113,9 @@ class Array {
*/
explicit Array(uint size)
{
m_size = size;
m_data = this->get_buffer_for_size(size);
default_construct_n(m_data, size);
size_ = size;
data_ = this->get_buffer_for_size(size);
default_construct_n(data_, size);
}
/**
@ -124,9 +124,9 @@ class Array {
*/
Array(uint size, const T &value)
{
m_size = size;
m_data = this->get_buffer_for_size(size);
uninitialized_fill_n(m_data, m_size, value);
size_ = size;
data_ = this->get_buffer_for_size(size);
uninitialized_fill_n(data_, size_, value);
}
/**
@ -143,39 +143,39 @@ class Array {
*/
Array(uint size, NoInitialization)
{
m_size = size;
m_data = this->get_buffer_for_size(size);
size_ = size;
data_ = this->get_buffer_for_size(size);
}
Array(const Array &other) : m_allocator(other.m_allocator)
Array(const Array &other) : allocator_(other.allocator_)
{
m_size = other.size();
size_ = other.size();
m_data = this->get_buffer_for_size(other.size());
uninitialized_copy_n(other.data(), m_size, m_data);
data_ = this->get_buffer_for_size(other.size());
uninitialized_copy_n(other.data(), size_, data_);
}
Array(Array &&other) noexcept : m_allocator(other.m_allocator)
Array(Array &&other) noexcept : allocator_(other.allocator_)
{
m_size = other.m_size;
size_ = other.size_;
if (!other.uses_inline_buffer()) {
m_data = other.m_data;
data_ = other.data_;
}
else {
m_data = this->get_buffer_for_size(m_size);
uninitialized_relocate_n(other.m_data, m_size, m_data);
data_ = this->get_buffer_for_size(size_);
uninitialized_relocate_n(other.data_, size_, data_);
}
other.m_data = other.inline_buffer();
other.m_size = 0;
other.data_ = other.inline_buffer();
other.size_ = 0;
}
~Array()
{
destruct_n(m_data, m_size);
destruct_n(data_, size_);
if (!this->uses_inline_buffer()) {
m_allocator.deallocate((void *)m_data);
allocator_.deallocate((void *)data_);
}
}
@ -203,12 +203,12 @@ class Array {
operator Span<T>() const
{
return Span<T>(m_data, m_size);
return Span<T>(data_, size_);
}
operator MutableSpan<T>()
{
return MutableSpan<T>(m_data, m_size);
return MutableSpan<T>(data_, size_);
}
Span<T> as_span() const
@ -223,14 +223,14 @@ class Array {
T &operator[](uint index)
{
BLI_assert(index < m_size);
return m_data[index];
BLI_assert(index < size_);
return data_[index];
}
const T &operator[](uint index) const
{
BLI_assert(index < m_size);
return m_data[index];
BLI_assert(index < size_);
return data_[index];
}
/**
@ -238,7 +238,7 @@ class Array {
*/
uint size() const
{
return m_size;
return size_;
}
/**
@ -246,7 +246,7 @@ class Array {
*/
bool is_empty() const
{
return m_size == 0;
return size_ == 0;
}
/**
@ -254,7 +254,7 @@ class Array {
*/
void fill(const T &value)
{
initialized_fill_n(m_data, m_size, value);
initialized_fill_n(data_, size_, value);
}
/**
@ -270,31 +270,31 @@ class Array {
*/
const T *data() const
{
return m_data;
return data_;
}
T *data()
{
return m_data;
return data_;
}
const T *begin() const
{
return m_data;
return data_;
}
const T *end() const
{
return m_data + m_size;
return data_ + size_;
}
T *begin()
{
return m_data;
return data_;
}
T *end()
{
return m_data + m_size;
return data_ + size_;
}
/**
@ -302,7 +302,7 @@ class Array {
*/
IndexRange index_range() const
{
return IndexRange(m_size);
return IndexRange(size_);
}
/**
@ -311,7 +311,7 @@ class Array {
*/
void clear_without_destruct()
{
m_size = 0;
size_ = 0;
}
/**
@ -319,7 +319,7 @@ class Array {
*/
Allocator &allocator()
{
return m_allocator;
return allocator_;
}
/**
@ -344,17 +344,17 @@ class Array {
T *inline_buffer() const
{
return (T *)m_inline_buffer.ptr();
return (T *)inline_buffer_.ptr();
}
T *allocate(uint size)
{
return (T *)m_allocator.allocate(size * sizeof(T), alignof(T), AT);
return (T *)allocator_.allocate(size * sizeof(T), alignof(T), AT);
}
bool uses_inline_buffer() const
{
return m_data == this->inline_buffer();
return data_ == this->inline_buffer();
}
};

70
source/blender/blenlib/BLI_dot_export.hh
View File

@ -49,25 +49,25 @@ class AttributeList;
class AttributeList {
private:
Map<std::string, std::string> m_attributes;
Map<std::string, std::string> attributes_;
public:
void export__as_bracket_list(std::stringstream &ss) const;
void set(StringRef key, StringRef value)
{
m_attributes.add_overwrite(key, value);
attributes_.add_overwrite(key, value);
}
};
class Graph {
private:
AttributeList m_attributes;
Vector<std::unique_ptr<Node>> m_nodes;
Vector<std::unique_ptr<Cluster>> m_clusters;
AttributeList attributes_;
Vector<std::unique_ptr<Node>> nodes_;
Vector<std::unique_ptr<Cluster>> clusters_;
Set<Node *> m_top_level_nodes;
Set<Cluster *> m_top_level_clusters;
Set<Node *> top_level_nodes_;
Set<Cluster *> top_level_clusters_;
friend Cluster;
friend Node;
@ -80,7 +80,7 @@ class Graph {
void set_attribute(StringRef key, StringRef value)
{
m_attributes.set(key, value);
attributes_.set(key, value);
}
void set_rankdir(Attr_rankdir rankdir)
@ -93,16 +93,16 @@ class Graph {
class Cluster {
private:
AttributeList m_attributes;
Graph &m_graph;
Cluster *m_parent = nullptr;
Set<Cluster *> m_children;
Set<Node *> m_nodes;
AttributeList attributes_;
Graph &graph_;
Cluster *parent_ = nullptr;
Set<Cluster *> children_;
Set<Node *> nodes_;
friend Graph;
friend Node;
Cluster(Graph &graph) : m_graph(graph)
Cluster(Graph &graph) : graph_(graph)
{
}
@ -111,7 +111,7 @@ class Cluster {
void set_attribute(StringRef key, StringRef value)
{
m_attributes.set(key, value);
attributes_.set(key, value);
}
void set_parent_cluster(Cluster *cluster);
@ -125,25 +125,25 @@ class Cluster {
class Node {
private:
AttributeList m_attributes;
Graph &m_graph;
Cluster *m_cluster = nullptr;
AttributeList attributes_;
Graph &graph_;
Cluster *cluster_ = nullptr;
friend Graph;
Node(Graph &graph) : m_graph(graph)
Node(Graph &graph) : graph_(graph)
{
}
public:
const AttributeList &attributes() const
{
return m_attributes;
return attributes_;
}
AttributeList &attributes()
{
return m_attributes;
return attributes_;
}
void set_parent_cluster(Cluster *cluster);
@ -154,7 +154,7 @@ class Node {
void set_attribute(StringRef key, StringRef value)
{
m_attributes.set(key, value);
attributes_.set(key, value);
}
void set_shape(Attr_shape shape)
@ -176,7 +176,7 @@ class Node {
class UndirectedGraph final : public Graph {
private:
Vector<std::unique_ptr<UndirectedEdge>> m_edges;
Vector<std::unique_ptr<UndirectedEdge>> edges_;
public:
std::string to_dot_string() const;
@ -186,7 +186,7 @@ class UndirectedGraph final : public Graph {
class DirectedGraph final : public Graph {
private:
Vector<std::unique_ptr<DirectedEdge>> m_edges;
Vector<std::unique_ptr<DirectedEdge>> edges_;
public:
std::string to_dot_string() const;
@ -196,12 +196,12 @@ class DirectedGraph final : public Graph {
class NodePort {
private:
Node *m_node;
std::optional<std::string> m_port_name;
Node *node_;
std::optional<std::string> port_name_;
public:
NodePort(Node &node, std::optional<std::string> port_name = {})
: m_node(&node), m_port_name(std::move(port_name))
: node_(&node), port_name_(std::move(port_name))
{
}
@ -210,18 +210,18 @@ class NodePort {
class Edge : blender::NonCopyable, blender::NonMovable {
protected:
AttributeList m_attributes;
NodePort m_a;
NodePort m_b;
AttributeList attributes_;
NodePort a_;
NodePort b_;
public:
Edge(NodePort a, NodePort b) : m_a(std::move(a)), m_b(std::move(b))
Edge(NodePort a, NodePort b) : a_(std::move(a)), b_(std::move(b))
{
}
void set_attribute(StringRef key, StringRef value)
{
m_attributes.set(key, value);
attributes_.set(key, value);
}
void set_arrowhead(Attr_arrowType type)
@ -262,7 +262,7 @@ std::string color_attr_from_hsv(float h, float s, float v);
class NodeWithSocketsRef {
private:
Node *m_node;
Node *node_;
public:
NodeWithSocketsRef(Node &node,
@ -273,13 +273,13 @@ class NodeWithSocketsRef {
NodePort input(uint index) const
{
std::string port = "\"in" + std::to_string(index) + "\"";
return NodePort(*m_node, port);
return NodePort(*node_, port);
}
NodePort output(uint index) const
{
std::string port = "\"out" + std::to_string(index) + "\"";
return NodePort(*m_node, port);
return NodePort(*node_, port);
}
};

80
source/blender/blenlib/BLI_hash_tables.hh
View File

@ -109,12 +109,12 @@ inline constexpr uint32_t total_slot_amount_for_usable_slots(uint32_t min_usable
class LoadFactor {
private:
uint8_t m_numerator;
uint8_t m_denominator;
uint8_t numerator_;
uint8_t denominator_;
public:
LoadFactor(uint8_t numerator, uint8_t denominator)
: m_numerator(numerator), m_denominator(denominator)
: numerator_(numerator), denominator_(denominator)
{
BLI_assert(numerator > 0);
BLI_assert(numerator < denominator);
@ -127,10 +127,10 @@ class LoadFactor {
{
BLI_assert(is_power_of_2_i((int)min_total_slots));
uint32_t total_slots = this->compute_total_slots(min_usable_slots, m_numerator, m_denominator);
uint32_t total_slots = this->compute_total_slots(min_usable_slots, numerator_, denominator_);
total_slots = std::max(total_slots, min_total_slots);
uint32_t usable_slots = floor_multiplication_with_fraction(
total_slots, m_numerator, m_denominator);
total_slots, numerator_, denominator_);
BLI_assert(min_usable_slots <= usable_slots);
*r_total_slots = total_slots;
@ -261,17 +261,17 @@ template<typename Pointer> struct PointerKeyInfo {
class HashTableStats {
private:
Vector<uint32_t> m_keys_by_collision_count;
uint32_t m_total_collisions;
float m_average_collisions;
uint32_t m_size;
uint32_t m_capacity;
uint32_t m_removed_amount;
float m_load_factor;
float m_removed_load_factor;
uint32_t m_size_per_element;
uint32_t m_size_in_bytes;
const void *m_address;
Vector<uint32_t> keys_by_collision_count_;
uint32_t total_collisions_;
float average_collisions_;
uint32_t size_;
uint32_t capacity_;
uint32_t removed_amount_;
float load_factor_;
float removed_load_factor_;
uint32_t size_per_element_;
uint32_t size_in_bytes_;
const void *address_;
public:
/**
@ -286,47 +286,47 @@ class HashTableStats {
template<typename HashTable, typename Keys>
HashTableStats(const HashTable &hash_table, const Keys &keys)
{
m_total_collisions = 0;
m_size = hash_table.size();
m_capacity = hash_table.capacity();
m_removed_amount = hash_table.removed_amount();
m_size_per_element = hash_table.size_per_element();
m_size_in_bytes = hash_table.size_in_bytes();
m_address = (const void *)&hash_table;
total_collisions_ = 0;
size_ = hash_table.size();
capacity_ = hash_table.capacity();
removed_amount_ = hash_table.removed_amount();
size_per_element_ = hash_table.size_per_element();
size_in_bytes_ = hash_table.size_in_bytes();
address_ = (const void *)&hash_table;
for (const auto &key : keys) {
uint32_t collisions = hash_table.count_collisions(key);
if (m_keys_by_collision_count.size() <= collisions) {
m_keys_by_collision_count.append_n_times(
0, collisions - m_keys_by_collision_count.size() + 1);
if (keys_by_collision_count_.size() <= collisions) {
keys_by_collision_count_.append_n_times(0,
collisions - keys_by_collision_count_.size() + 1);
}
m_keys_by_collision_count[collisions]++;
m_total_collisions += collisions;
keys_by_collision_count_[collisions]++;
total_collisions_ += collisions;
}
m_average_collisions = (m_size == 0) ? 0 : (float)m_total_collisions / (float)m_size;
m_load_factor = (float)m_size / (float)m_capacity;
m_removed_load_factor = (float)m_removed_amount / (float)m_capacity;
average_collisions_ = (size_ == 0) ? 0 : (float)total_collisions_ / (float)size_;
load_factor_ = (float)size_ / (float)capacity_;
removed_load_factor_ = (float)removed_amount_ / (float)capacity_;
}
void print(StringRef name = "")
{
std::cout << "Hash Table Stats: " << name << "\n";
std::cout << " Address: " << m_address << "\n";
std::cout << " Total Slots: " << m_capacity << "\n";
std::cout << " Occupied Slots: " << m_size << " (" << m_load_factor * 100.0f << " %)\n";
std::cout << " Removed Slots: " << m_removed_amount << " (" << m_removed_load_factor * 100.0f
std::cout << " Address: " << address_ << "\n";
std::cout << " Total Slots: " << capacity_ << "\n";
std::cout << " Occupied Slots: " << size_ << " (" << load_factor_ * 100.0f << " %)\n";
std::cout << " Removed Slots: " << removed_amount_ << " (" << removed_load_factor_ * 100.0f
<< " %)\n";
char memory_size_str[15];
BLI_str_format_byte_unit(memory_size_str, m_size_in_bytes, true);
BLI_str_format_byte_unit(memory_size_str, size_in_bytes_, true);
std::cout << " Size: ~" << memory_size_str << "\n";
std::cout << " Size per Slot: " << m_size_per_element << " bytes\n";
std::cout << " Size per Slot: " << size_per_element_ << " bytes\n";
std::cout << " Average Collisions: " << m_average_collisions << "\n";
for (uint32_t collision_count : m_keys_by_collision_count.index_range()) {
std::cout << " Average Collisions: " << average_collisions_ << "\n";
for (uint32_t collision_count : keys_by_collision_count_.index_range()) {
std::cout << " " << collision_count
<< " Collisions: " << m_keys_by_collision_count[collision_count] << "\n";
<< " Collisions: " << keys_by_collision_count_[collision_count] << "\n";
}
}
};

32
source/blender/blenlib/BLI_index_mask.hh
View File

@ -46,7 +46,7 @@ namespace blender {
class IndexMask {
private:
/* The underlying reference to sorted integers. */
Span<uint> m_indices;
Span<uint> indices_;
public:
/* Creates an IndexMask that contains no indices. */
@ -57,7 +57,7 @@ class IndexMask {
* This constructor asserts that the given integers are in ascending order and that there are no
* duplicates.
*/
IndexMask(Span<uint> indices) : m_indices(indices)
IndexMask(Span<uint> indices) : indices_(indices)
{
#ifdef DEBUG
for (uint i = 1; i < indices.size(); i++) {
@ -70,7 +70,7 @@ class IndexMask {
* Use this method when you know that no indices are skipped. It is more efficient than preparing
* an integer array all the time.
*/
IndexMask(IndexRange range) : m_indices(range.as_span())
IndexMask(IndexRange range) : indices_(range.as_span())
{
}
@ -97,17 +97,17 @@ class IndexMask {
operator Span<uint>() const
{
return m_indices;
return indices_;
}
const uint *begin() const
{
return m_indices.begin();
return indices_.begin();
}
const uint *end() const
{
return m_indices.end();
return indices_.end();
}
/**
@ -116,7 +116,7 @@ class IndexMask {
*/
uint operator[](uint n) const
{
return m_indices[n];
return indices_[n];
}
/**
@ -125,17 +125,17 @@ class IndexMask {
*/
uint min_array_size() const
{
if (m_indices.size() == 0) {
if (indices_.size() == 0) {
return 0;
}
else {
return m_indices.last() + 1;
return indices_.last() + 1;
}
}
Span<uint> indices() const
{
return m_indices;
return indices_;
}
/**
@ -143,7 +143,7 @@ class IndexMask {
*/
bool is_range() const
{
return m_indices.size() > 0 && m_indices.last() - m_indices.first() == m_indices.size() - 1;
return indices_.size() > 0 && indices_.last() - indices_.first() == indices_.size() - 1;
}
/**
@ -153,7 +153,7 @@ class IndexMask {
IndexRange as_range() const
{
BLI_assert(this->is_range());
return IndexRange{m_indices.first(), m_indices.size()};
return IndexRange{indices_.first(), indices_.size()};
}
/**
@ -172,7 +172,7 @@ class IndexMask {
}
}
else {
for (uint i : m_indices) {
for (uint i : indices_) {
callback(i);
}
}
@ -187,7 +187,7 @@ class IndexMask {
*/
IndexRange index_range() const
{
return m_indices.index_range();
return indices_.index_range();
}
/**
@ -195,7 +195,7 @@ class IndexMask {
*/
uint last() const
{
return m_indices.last();
return indices_.last();
}
/**
@ -203,7 +203,7 @@ class IndexMask {
*/
uint size() const
{
return m_indices.size();
return indices_.size();
}
};

48
source/blender/blenlib/BLI_index_range.hh
View File

@ -70,59 +70,59 @@ template<typename T> class Span;
class IndexRange {
private:
uint m_start = 0;
uint m_size = 0;
uint start_ = 0;
uint size_ = 0;
public:
IndexRange() = default;
explicit IndexRange(uint size) : m_start(0), m_size(size)
explicit IndexRange(uint size) : start_(0), size_(size)
{
}
IndexRange(uint start, uint size) : m_start(start), m_size(size)
IndexRange(uint start, uint size) : start_(start), size_(size)
{
}
template<typename T>
IndexRange(const tbb::blocked_range<T> &range) : m_start(range.begin()), m_size(range.size())
IndexRange(const tbb::blocked_range<T> &range) : start_(range.begin()), size_(range.size())
{
}
class Iterator {
private:
uint m_current;
uint current_;
public:
Iterator(uint current) : m_current(current)
Iterator(uint current) : current_(current)
{
}
Iterator &operator++()
{
m_current++;
current_++;
return *this;
}
bool operator!=(const Iterator &iterator) const
{
return m_current != iterator.m_current;
return current_ != iterator.current_;
}
uint operator*() const
{
return m_current;
return current_;
}
};
Iterator begin() const
{
return Iterator(m_start);
return Iterator(start_);
}
Iterator end() const
{
return Iterator(m_start + m_size);
return Iterator(start_ + size_);
}
/**
@ -131,7 +131,7 @@ class IndexRange {
uint operator[](uint index) const
{
BLI_assert(index < this->size());
return m_start + index;
return start_ + index;
}
/**
@ -139,7 +139,7 @@ class IndexRange {
*/
friend bool operator==(IndexRange a, IndexRange b)
{
return (a.m_size == b.m_size) && (a.m_start == b.m_start || a.m_size == 0);
return (a.size_ == b.size_) && (a.start_ == b.start_ || a.size_ == 0);
}
/**
@ -147,7 +147,7 @@ class IndexRange {
*/
uint size() const
{
return m_size;
return size_;
}
/**
@ -155,7 +155,7 @@ class IndexRange {
*/
IndexRange after(uint n) const
{
return IndexRange(m_start + m_size, n);
return IndexRange(start_ + size_, n);
}
/**
@ -163,7 +163,7 @@ class IndexRange {
*/
IndexRange before(uint n) const
{
return IndexRange(m_start - n, n);
return IndexRange(start_ - n, n);
}
/**
@ -173,7 +173,7 @@ class IndexRange {
uint first() const
{
BLI_assert(this->size() > 0);
return m_start;
return start_;
}
/**
@ -183,7 +183,7 @@ class IndexRange {
uint last() const
{
BLI_assert(this->size() > 0);
return m_start + m_size - 1;
return start_ + size_ - 1;
}
/**
@ -191,7 +191,7 @@ class IndexRange {
*/
uint one_after_last() const
{
return m_start + m_size;
return start_ + size_;
}
/**
@ -199,7 +199,7 @@ class IndexRange {
*/
uint start() const
{
return m_start;
return start_;
}
/**
@ -207,7 +207,7 @@ class IndexRange {
*/
bool contains(uint value) const
{
return value >= m_start && value < m_start + m_size;
return value >= start_ && value < start_ + size_;
}
/**
@ -215,8 +215,8 @@ class IndexRange {
*/
IndexRange slice(uint start, uint size) const
{
uint new_start = m_start + start;
BLI_assert(new_start + size <= m_start + m_size || size == 0);
uint new_start = start_ + start;
BLI_assert(new_start + size <= start_ + size_ || size == 0);
return IndexRange(new_start, size);
}
IndexRange slice(IndexRange range) const

56
source/blender/blenlib/BLI_linear_allocator.hh
View File

@ -33,30 +33,30 @@ namespace blender {
template<typename Allocator = GuardedAllocator> class LinearAllocator : NonCopyable, NonMovable {
private:
Allocator m_allocator;
Vector<void *> m_owned_buffers;
Vector<Span<char>> m_unused_borrowed_buffers;
Allocator allocator_;
Vector<void *> owned_buffers_;
Vector<Span<char>> unused_borrowed_buffers_;
uintptr_t m_current_begin;
uintptr_t m_current_end;
uint m_next_min_alloc_size;
uintptr_t current_begin_;
uintptr_t current_end_;
uint next_min_alloc_size_;
#ifdef DEBUG
uint m_debug_allocated_amount = 0;
uint debug_allocated_amount_ = 0;
#endif
public:
LinearAllocator()
{
m_current_begin = 0;
m_current_end = 0;
m_next_min_alloc_size = 64;
current_begin_ = 0;
current_end_ = 0;
next_min_alloc_size_ = 64;
}
~LinearAllocator()
{
for (void *ptr : m_owned_buffers) {
m_allocator.deallocate(ptr);
for (void *ptr : owned_buffers_) {
allocator_.deallocate(ptr);
}
}
@ -72,15 +72,15 @@ template<typename Allocator = GuardedAllocator> class LinearAllocator : NonCopya
BLI_assert(is_power_of_2_i(alignment));
#ifdef DEBUG
m_debug_allocated_amount += size;
debug_allocated_amount_ += size;
#endif
uintptr_t alignment_mask = alignment - 1;
uintptr_t potential_allocation_begin = (m_current_begin + alignment_mask) & ~alignment_mask;
uintptr_t potential_allocation_begin = (current_begin_ + alignment_mask) & ~alignment_mask;
uintptr_t potential_allocation_end = potential_allocation_begin + size;
if (potential_allocation_end <= m_current_end) {
m_current_begin = potential_allocation_end;
if (potential_allocation_end <= current_end_) {
current_begin_ = potential_allocation_end;
return (void *)potential_allocation_begin;
}
else {
@ -183,7 +183,7 @@ template<typename Allocator = GuardedAllocator> class LinearAllocator : NonCopya
*/
void provide_buffer(void *buffer, uint size)
{
m_unused_borrowed_buffers.append(Span<char>((char *)buffer, size));
unused_borrowed_buffers_.append(Span<char>((char *)buffer, size));
}
template<size_t Size, size_t Alignment>
@ -195,23 +195,23 @@ template<typename Allocator = GuardedAllocator> class LinearAllocator : NonCopya
private:
void allocate_new_buffer(uint min_allocation_size)
{
for (uint i : m_unused_borrowed_buffers.index_range()) {
Span<char> buffer = m_unused_borrowed_buffers[i];
for (uint i : unused_borrowed_buffers_.index_range()) {
Span<char> buffer = unused_borrowed_buffers_[i];
if (buffer.size() >= min_allocation_size) {
m_unused_borrowed_buffers.remove_and_reorder(i);
m_current_begin = (uintptr_t)buffer.begin();
m_current_end = (uintptr_t)buffer.end();
unused_borrowed_buffers_.remove_and_reorder(i);
current_begin_ = (uintptr_t)buffer.begin();
current_end_ = (uintptr_t)buffer.end();
return;
}
}
uint size_in_bytes = power_of_2_min_u(std::max(min_allocation_size, m_next_min_alloc_size));
m_next_min_alloc_size = size_in_bytes * 2;
uint size_in_bytes = power_of_2_min_u(std::max(min_allocation_size, next_min_alloc_size_));
next_min_alloc_size_ = size_in_bytes * 2;
void *buffer = m_allocator.allocate(size_in_bytes, 8, AT);
m_owned_buffers.append(buffer);
m_current_begin = (uintptr_t)buffer;
m_current_end = m_current_begin + size_in_bytes;
void *buffer = allocator_.allocate(size_in_bytes, 8, AT);
owned_buffers_.append(buffer);
current_begin_ = (uintptr_t)buffer;
current_end_ = current_begin_ + size_in_bytes;
}
};

22
source/blender/blenlib/BLI_listbase_wrapper.hh
View File

@ -33,10 +33,10 @@ namespace blender {
template<typename T> class ListBaseWrapper {
private:
ListBase *m_listbase;
ListBase *listbase_;
public:
ListBaseWrapper(ListBase *listbase) : m_listbase(listbase)
ListBaseWrapper(ListBase *listbase) : listbase_(listbase)
{
BLI_assert(listbase);
}
@ -47,17 +47,17 @@ template<typename T> class ListBaseWrapper {
class Iterator {
private:
ListBase *m_listbase;
T *m_current;
ListBase *listbase_;
T *current_;
public:
Iterator(ListBase *listbase, T *current) : m_listbase(listbase), m_current(current)
Iterator(ListBase *listbase, T *current) : listbase_(listbase), current_(current)
{
}
Iterator &operator++()
{
m_current = m_current->next;
current_ = current_->next;
return *this;
}
@ -70,28 +70,28 @@ template<typename T> class ListBaseWrapper {
bool operator!=(const Iterator &iterator) const
{
return m_current != iterator.m_current;
return current_ != iterator.current_;
}
T *operator*() const
{
return m_current;
return current_;
}
};
Iterator begin() const
{
return Iterator(m_listbase, (T *)m_listbase->first);
return Iterator(listbase_, (T *)listbase_->first);
}
Iterator end() const
{
return Iterator(m_listbase, nullptr);
return Iterator(listbase_, nullptr);
}
T get(uint index) const
{
void *ptr = BLI_findlink(m_listbase, index);
void *ptr = BLI_findlink(listbase_, index);
BLI_assert(ptr);
return (T *)ptr;
}

238
source/blender/blenlib/BLI_map.hh
View File

@ -129,30 +129,30 @@ class Map {
* Slots are either empty, occupied or removed. The number of occupied slots can be computed by
* subtracting the removed slots from the occupied-and-removed slots.
*/
uint32_t m_removed_slots;
uint32_t m_occupied_and_removed_slots;
uint32_t removed_slots_;
uint32_t occupied_and_removed_slots_;
/**
* The maximum number of slots that can be used (either occupied or removed) until the set has to
* grow. This is the total number of slots times the max load factor.
*/
uint32_t m_usable_slots;
uint32_t usable_slots_;
/**
* The number of slots minus one. This is a bit mask that can be used to turn any integer into a
* valid slot index efficiently.
*/
uint32_t m_slot_mask;
uint32_t slot_mask_;
/** This is called to hash incoming keys. */
Hash m_hash;
Hash hash_;
/** This is called to check equality of two keys. */
IsEqual m_is_equal;
IsEqual is_equal_;
/** The max load factor is 1/2 = 50% by default. */
#define LOAD_FACTOR 1, 2
LoadFactor m_max_load_factor = LoadFactor(LOAD_FACTOR);
LoadFactor max_load_factor_ = LoadFactor(LOAD_FACTOR);
using SlotArray =
Array<Slot, LoadFactor::compute_total_slots(InlineBufferCapacity, LOAD_FACTOR), Allocator>;
#undef LOAD_FACTOR
@ -161,12 +161,12 @@ class Map {
* This is the array that contains the actual slots. There is always at least one empty slot and
* the size of the array is a power of two.
*/
SlotArray m_slots;
SlotArray slots_;
/** Iterate over a slot index sequence for a given hash. */
#define MAP_SLOT_PROBING_BEGIN(HASH, R_SLOT) \
SLOT_PROBING_BEGIN (ProbingStrategy, HASH, m_slot_mask, SLOT_INDEX) \
auto &R_SLOT = m_slots[SLOT_INDEX];
SLOT_PROBING_BEGIN (ProbingStrategy, HASH, slot_mask_, SLOT_INDEX) \
auto &R_SLOT = slots_[SLOT_INDEX];
#define MAP_SLOT_PROBING_END() SLOT_PROBING_END()
public:
@ -176,13 +176,13 @@ class Map {
* operation is performed on the first insertion.
*/
Map()
: m_removed_slots(0),
m_occupied_and_removed_slots(0),
m_usable_slots(0),
m_slot_mask(0),
m_hash(),
m_is_equal(),
m_slots(1)
: removed_slots_(0),
occupied_and_removed_slots_(0),
usable_slots_(0),
slot_mask_(0),
hash_(),
is_equal_(),
slots_(1)
{
}
@ -191,13 +191,13 @@ class Map {
Map(const Map &other) = default;
Map(Map &&other) noexcept
: m_removed_slots(other.m_removed_slots),
m_occupied_and_removed_slots(other.m_occupied_and_removed_slots),
m_usable_slots(other.m_usable_slots),
m_slot_mask(other.m_slot_mask),
m_hash(std::move(other.m_hash)),
m_is_equal(std::move(other.m_is_equal)),
m_slots(std::move(other.m_slots))
: removed_slots_(other.removed_slots_),
occupied_and_removed_slots_(other.occupied_and_removed_slots_),
usable_slots_(other.usable_slots_),
slot_mask_(other.slot_mask_),
hash_(std::move(other.hash_)),
is_equal_(std::move(other.is_equal_)),
slots_(std::move(other.slots_))
{
other.~Map();
new (&other) Map();
@ -233,19 +233,19 @@ class Map {
*/
void add_new(const Key &key, const Value &value)
{
this->add_new__impl(key, value, m_hash(key));
this->add_new__impl(key, value, hash_(key));
}
void add_new(const Key &key, Value &&value)
{
this->add_new__impl(key, std::move(value), m_hash(key));
this->add_new__impl(key, std::move(value), hash_(key));
}
void add_new(Key &&key, const Value &value)
{
this->add_new__impl(std::move(key), value, m_hash(key));
this->add_new__impl(std::move(key), value, hash_(key));
}
void add_new(Key &&key, Value &&value)
{
this->add_new__impl(std::move(key), std::move(value), m_hash(key));
this->add_new__impl(std::move(key), std::move(value), hash_(key));
}
/**
@ -279,7 +279,7 @@ class Map {
bool add_as(ForwardKey &&key, ForwardValue &&value)
{
return this->add__impl(
std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), m_hash(key));
std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), hash_(key));
}
/**
@ -313,7 +313,7 @@ class Map {
bool add_overwrite_as(ForwardKey &&key, ForwardValue &&value)
{
return this->add_overwrite__impl(
std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), m_hash(key));
std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), hash_(key));
}
/**
@ -331,7 +331,7 @@ class Map {
*/
template<typename ForwardKey> bool contains_as(const ForwardKey &key) const
{
return this->contains__impl(key, m_hash(key));
return this->contains__impl(key, hash_(key));
}
/**
@ -350,7 +350,7 @@ class Map {
*/
template<typename ForwardKey> bool remove_as(const ForwardKey &key)
{
return this->remove__impl(key, m_hash(key));
return this->remove__impl(key, hash_(key));
}
/**
@ -368,7 +368,7 @@ class Map {
*/
template<typename ForwardKey> void remove_contained_as(const ForwardKey &key)
{
this->remove_contained__impl(key, m_hash(key));
this->remove_contained__impl(key, hash_(key));
}
/**
@ -385,7 +385,7 @@ class Map {
*/
template<typename ForwardKey> Value pop_as(const ForwardKey &key)
{
return this->pop__impl(key, m_hash(key));
return this->pop__impl(key, hash_(key));
}
/**
@ -402,7 +402,7 @@ class Map {
*/
template<typename ForwardKey> std::optional<Value> pop_try_as(const ForwardKey &key)
{
return this->pop_try__impl(key, m_hash(key));
return this->pop_try__impl(key, hash_(key));
}
/**
@ -424,7 +424,7 @@ class Map {
template<typename ForwardKey, typename ForwardValue>
Value pop_default_as(const ForwardKey &key, ForwardValue &&default_value)
{
return this->pop_default__impl(key, std::forward<ForwardValue>(default_value), m_hash(key));
return this->pop_default__impl(key, std::forward<ForwardValue>(default_value), hash_(key));
}
/**
@ -470,7 +470,7 @@ class Map {
const ModifyValueF &modify_value) -> decltype(create_value(nullptr))
{
return this->add_or_modify__impl(
std::forward<ForwardKey>(key), create_value, modify_value, m_hash(key));
std::forward<ForwardKey>(key), create_value, modify_value, hash_(key));
}
/**
@ -493,11 +493,11 @@ class Map {
*/
template<typename ForwardKey> const Value *lookup_ptr_as(const ForwardKey &key) const
{
return this->lookup_ptr__impl(key, m_hash(key));
return this->lookup_ptr__impl(key, hash_(key));
}
template<typename ForwardKey> Value *lookup_ptr_as(const ForwardKey &key)
{
return const_cast<Value *>(this->lookup_ptr__impl(key, m_hash(key)));
return const_cast<Value *>(this->lookup_ptr__impl(key, hash_(key)));
}
/**
@ -582,7 +582,7 @@ class Map {
Value &lookup_or_add_as(ForwardKey &&key, ForwardValue &&value)
{
return this->lookup_or_add__impl(
std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), m_hash(key));
std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), hash_(key));
}
/**
@ -610,7 +610,7 @@ class Map {
template<typename ForwardKey, typename CreateValueF>
Value &lookup_or_add_cb_as(ForwardKey &&key, const CreateValueF &create_value)
{
return this->lookup_or_add_cb__impl(std::forward<ForwardKey>(key), create_value, m_hash(key));
return this->lookup_or_add_cb__impl(std::forward<ForwardKey>(key), create_value, hash_(key));
}
/**
@ -641,9 +641,9 @@ class Map {
*/
template<typename FuncT> void foreach_item(const FuncT &func) const
{
uint32_t size = m_slots.size();
uint32_t size = slots_.size();
for (uint32_t i = 0; i < size; i++) {
const Slot &slot = m_slots[i];
const Slot &slot = slots_[i];
if (slot.is_occupied()) {
const Key &key = *slot.key();
const Value &value = *slot.value();
@ -657,21 +657,19 @@ class Map {
* This uses the "curiously recurring template pattern" (CRTP).
*/
template<typename SubIterator> struct BaseIterator {
Slot *m_slots;
uint32_t m_total_slots;
uint32_t m_current_slot;
Slot *slots_;
uint32_t total_slots_;
uint32_t current_slot_;
BaseIterator(const Slot *slots, uint32_t total_slots, uint32_t current_slot)
: m_slots(const_cast<Slot *>(slots)),
m_total_slots(total_slots),
m_current_slot(current_slot)
: slots_(const_cast<Slot *>(slots)), total_slots_(total_slots), current_slot_(current_slot)
{
}
BaseIterator &operator++()
{
while (++m_current_slot < m_total_slots) {
if (m_slots[m_current_slot].is_occupied()) {
while (++current_slot_ < total_slots_) {
if (slots_[current_slot_].is_occupied()) {
break;
}
}
@ -680,16 +678,16 @@ class Map {
friend bool operator!=(const BaseIterator &a, const BaseIterator &b)
{
BLI_assert(a.m_slots == b.m_slots);
BLI_assert(a.m_total_slots == b.m_total_slots);
return a.m_current_slot != b.m_current_slot;
BLI_assert(a.slots_ == b.slots_);
BLI_assert(a.total_slots_ == b.total_slots_);
return a.current_slot_ != b.current_slot_;
}
SubIterator begin() const
{
for (uint32_t i = 0; i < m_total_slots; i++) {
if (m_slots[i].is_occupied()) {
return SubIterator(m_slots, m_total_slots, i);
for (uint32_t i = 0; i < total_slots_; i++) {
if (slots_[i].is_occupied()) {
return SubIterator(slots_, total_slots_, i);
}
}
return this->end();
@ -697,12 +695,12 @@ class Map {
SubIterator end() const
{
return SubIterator(m_slots, m_total_slots, m_total_slots);
return SubIterator(slots_, total_slots_, total_slots_);
}
Slot &current_slot() const
{
return m_slots[m_current_slot];
return slots_[current_slot_];
}
};
@ -794,7 +792,7 @@ class Map {
*/
KeyIterator keys() const
{
return KeyIterator(m_slots.data(), m_slots.size(), 0);
return KeyIterator(slots_.data(), slots_.size(), 0);
}
/**
@ -803,7 +801,7 @@ class Map {
*/
ValueIterator values() const
{
return ValueIterator(m_slots.data(), m_slots.size(), 0);
return ValueIterator(slots_.data(), slots_.size(), 0);
}
/**
@ -812,7 +810,7 @@ class Map {
*/
MutableValueIterator values()
{
return MutableValueIterator(m_slots.data(), m_slots.size(), 0);
return MutableValueIterator(slots_.data(), slots_.size(), 0);
}
/**
@ -822,7 +820,7 @@ class Map {
*/
ItemIterator items() const
{
return ItemIterator(m_slots.data(), m_slots.size(), 0);
return ItemIterator(slots_.data(), slots_.size(), 0);
}
/**
@ -834,7 +832,7 @@ class Map {
*/
MutableItemIterator items()
{
return MutableItemIterator(m_slots.data(), m_slots.size(), 0);
return MutableItemIterator(slots_.data(), slots_.size(), 0);
}
/**
@ -851,7 +849,7 @@ class Map {
*/
uint32_t size() const
{
return m_occupied_and_removed_slots - m_removed_slots;
return occupied_and_removed_slots_ - removed_slots_;
}
/**
@ -861,7 +859,7 @@ class Map {
*/
bool is_empty() const
{
return m_occupied_and_removed_slots == m_removed_slots;
return occupied_and_removed_slots_ == removed_slots_;
}
/**
@ -869,7 +867,7 @@ class Map {
*/
uint32_t capacity() const
{
return m_slots.size();
return slots_.size();
}
/**
@ -877,7 +875,7 @@ class Map {
*/
uint32_t removed_amount() const
{
return m_removed_slots;
return removed_slots_;
}
/**
@ -894,7 +892,7 @@ class Map {
*/
uint32_t size_in_bytes() const
{
return (uint32_t)(sizeof(Slot) * m_slots.size());
return (uint32_t)(sizeof(Slot) * slots_.size());
}
/**
@ -903,7 +901,7 @@ class Map {
*/
void reserve(uint32_t n)
{
if (m_usable_slots < n) {
if (usable_slots_ < n) {
this->realloc_and_reinsert(n);
}
}
@ -923,14 +921,14 @@ class Map {
*/
uint32_t count_collisions(const Key &key) const
{
return this->count_collisions__impl(key, m_hash(key));
return this->count_collisions__impl(key, hash_(key));
}
private:
BLI_NOINLINE void realloc_and_reinsert(uint32_t min_usable_slots)
{
uint32_t total_slots, usable_slots;
m_max_load_factor.compute_total_and_usable_slots(
max_load_factor_.compute_total_and_usable_slots(
SlotArray::inline_buffer_capacity(), min_usable_slots, &total_slots, &usable_slots);
uint32_t new_slot_mask = total_slots - 1;
@ -938,18 +936,18 @@ class Map {
* Optimize the case when the map was empty beforehand. We can avoid some copies here.
*/
if (this->size() == 0) {
m_slots.~Array();
new (&m_slots) SlotArray(total_slots);
m_removed_slots = 0;
m_occupied_and_removed_slots = 0;
m_usable_slots = usable_slots;
m_slot_mask = new_slot_mask;
slots_.~Array();
new (&slots_) SlotArray(total_slots);
removed_slots_ = 0;
occupied_and_removed_slots_ = 0;
usable_slots_ = usable_slots;
slot_mask_ = new_slot_mask;
return;
}
SlotArray new_slots(total_slots);
for (Slot &slot : m_slots) {
for (Slot &slot : slots_) {
if (slot.is_occupied()) {
this->add_after_grow_and_destruct_old(slot, new_slots, new_slot_mask);
}
@ -957,12 +955,12 @@ class Map {
/* All occupied slots have been destructed already and empty/removed slots are assumed to be
* trivially destructible. */
m_slots.clear_without_destruct();
m_slots = std::move(new_slots);
m_occupied_and_removed_slots -= m_removed_slots;
m_usable_slots = usable_slots;
m_removed_slots = 0;
m_slot_mask = new_slot_mask;
slots_.clear_without_destruct();
slots_ = std::move(new_slots);
occupied_and_removed_slots_ -= removed_slots_;
usable_slots_ = usable_slots;
removed_slots_ = 0;
slot_mask_ = new_slot_mask;
}
void add_after_grow_and_destruct_old(Slot &old_slot,
@ -986,7 +984,7 @@ class Map {
if (slot.is_empty()) {
return false;
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return true;
}
}
@ -999,7 +997,7 @@ class Map {
BLI_assert(!this->contains_as(key));
this->ensure_can_add();
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
@ -1018,10 +1016,10 @@ class Map {
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
slot.occupy(std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), hash);
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
return true;
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return false;
}
}
@ -1031,9 +1029,9 @@ class Map {
template<typename ForwardKey> bool remove__impl(const ForwardKey &key, uint32_t hash)
{
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
slot.remove();
m_removed_slots++;
removed_slots_++;
return true;
}
if (slot.is_empty()) {
@ -1047,10 +1045,10 @@ class Map {
{
BLI_assert(this->contains_as(key));
m_removed_slots++;
removed_slots_++;
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
slot.remove();
return;
}
@ -1062,10 +1060,10 @@ class Map {
{
BLI_assert(this->contains_as(key));
m_removed_slots++;
removed_slots_++;
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
Value value = std::move(*slot.value());
slot.remove();
return value;
@ -1078,10 +1076,10 @@ class Map {
std::optional<Value> pop_try__impl(const ForwardKey &key, uint32_t hash)
{
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
std::optional<Value> value = std::move(*slot.value());
slot.remove();
m_removed_slots++;
removed_slots_++;
return value;
}
if (slot.is_empty()) {
@ -1095,10 +1093,10 @@ class Map {
Value pop_default__impl(const ForwardKey &key, ForwardValue &&default_value, uint32_t hash)
{
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
Value value = std::move(*slot.value());
slot.remove();
m_removed_slots++;
removed_slots_++;
return value;
}
if (slot.is_empty()) {
@ -1123,12 +1121,12 @@ class Map {
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
slot.occupy_without_value(std::forward<ForwardKey>(key), hash);
Value *value_ptr = slot.value();
return create_value(value_ptr);
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
Value *value_ptr = slot.value();
return modify_value(value_ptr);
}
@ -1144,10 +1142,10 @@ class Map {
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
slot.occupy(std::forward<ForwardKey>(key), create_value(), hash);
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
return *slot.value();
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return *slot.value();
}
}
@ -1162,10 +1160,10 @@ class Map {
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
slot.occupy(std::forward<ForwardKey>(key), std::forward<ForwardValue>(value), hash);
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
return *slot.value();
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return *slot.value();
}
}
@ -1194,7 +1192,7 @@ class Map {
if (slot.is_empty()) {
return nullptr;
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return slot.value();
}
}
@ -1207,7 +1205,7 @@ class Map {
uint32_t collisions = 0;
MAP_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return collisions;
}
if (slot.is_empty()) {
@ -1220,9 +1218,9 @@ class Map {
void ensure_can_add()
{
if (m_occupied_and_removed_slots >= m_usable_slots) {
if (occupied_and_removed_slots_ >= usable_slots_) {
this->realloc_and_reinsert(this->size() + 1);
BLI_assert(m_occupied_and_removed_slots < m_usable_slots);
BLI_assert(occupied_and_removed_slots_ < usable_slots_);
}
}
};
@ -1234,59 +1232,59 @@ class Map {
template<typename Key, typename Value> class StdUnorderedMapWrapper {
private:
using MapType = std::unordered_map<Key, Value, blender::DefaultHash<Key>>;
MapType m_map;
MapType map_;
public:
uint32_t size() const
{
return (uint32_t)m_map.size();
return (uint32_t)map_.size();
}
bool is_empty() const
{
return m_map.empty();
return map_.empty();
}
void reserve(uint32_t n)
{
m_map.reserve(n);
map_.reserve(n);
}
template<typename ForwardKey, typename ForwardValue>
void add_new(ForwardKey &&key, ForwardValue &&value)
{
m_map.insert({std::forward<ForwardKey>(key), std::forward<ForwardValue>(value)});
map_.insert({std::forward<ForwardKey>(key), std::forward<ForwardValue>(value)});
}
template<typename ForwardKey, typename ForwardValue>
bool add(ForwardKey &&key, ForwardValue &&value)
{
return m_map.insert({std::forward<ForwardKey>(key), std::forward<ForwardValue>(value)}).second;
return map_.insert({std::forward<ForwardKey>(key), std::forward<ForwardValue>(value)}).second;
}
bool contains(const Key &key) const
{
return m_map.find(key) != m_map.end();
return map_.find(key) != map_.end();
}
bool remove(const Key &key)
{
return (bool)m_map.erase(key);
return (bool)map_.erase(key);
}
Value &lookup(const Key &key)
{
return m_map.find(key)->second;
return map_.find(key)->second;
}
const Value &lookup(const Key &key) const
{
return m_map.find(key)->second;
return map_.find(key)->second;
}
void clear()
{
m_map.clear();
map_.clear();
}
void print_stats(StringRef UNUSED(name) = "") const

74
source/blender/blenlib/BLI_map_slots.hh
View File

@ -52,9 +52,9 @@ template<typename Key, typename Value> class SimpleMapSlot {
Removed = 2,
};
State m_state;
AlignedBuffer<sizeof(Key), alignof(Key)> m_key_buffer;
AlignedBuffer<sizeof(Value), alignof(Value)> m_value_buffer;
State state_;
AlignedBuffer<sizeof(Key), alignof(Key)> key_buffer_;
AlignedBuffer<sizeof(Value), alignof(Value)> value_buffer_;
public:
/**
@ -62,7 +62,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
SimpleMapSlot()
{
m_state = Empty;
state_ = Empty;
}
/**
@ -70,7 +70,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
~SimpleMapSlot()
{
if (m_state == Occupied) {
if (state_ == Occupied) {
this->key()->~Key();
this->value()->~Value();
}
@ -82,8 +82,8 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
SimpleMapSlot(const SimpleMapSlot &other)
{
m_state = other.m_state;
if (other.m_state == Occupied) {
state_ = other.state_;
if (other.state_ == Occupied) {
new ((void *)this->key()) Key(*other.key());
new ((void *)this->value()) Value(*other.value());
}
@ -96,8 +96,8 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
SimpleMapSlot(SimpleMapSlot &&other) noexcept
{
m_state = other.m_state;
if (other.m_state == Occupied) {
state_ = other.state_;
if (other.state_ == Occupied) {
new ((void *)this->key()) Key(std::move(*other.key()));
new ((void *)this->value()) Value(std::move(*other.value()));
}
@ -108,7 +108,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
Key *key()
{
return (Key *)m_key_buffer.ptr();
return (Key *)key_buffer_.ptr();
}
/**
@ -116,7 +116,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
const Key *key() const
{
return (const Key *)m_key_buffer.ptr();
return (const Key *)key_buffer_.ptr();
}
/**
@ -124,7 +124,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
Value *value()
{
return (Value *)m_value_buffer.ptr();
return (Value *)value_buffer_.ptr();
}
/**
@ -132,7 +132,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
const Value *value() const
{
return (const Value *)m_value_buffer.ptr();
return (const Value *)value_buffer_.ptr();
}
/**
@ -140,7 +140,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
bool is_occupied() const
{
return m_state == Occupied;
return state_ == Occupied;
}
/**
@ -148,7 +148,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
bool is_empty() const
{
return m_state == Empty;
return state_ == Empty;
}
/**
@ -169,7 +169,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
{
BLI_assert(!this->is_occupied());
BLI_assert(other.is_occupied());
m_state = Occupied;
state_ = Occupied;
new ((void *)this->key()) Key(std::move(*other.key()));
new ((void *)this->value()) Value(std::move(*other.value()));
other.key()->~Key();
@ -183,7 +183,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint32_t UNUSED(hash)) const
{
if (m_state == Occupied) {
if (state_ == Occupied) {
return is_equal(key, *this->key());
}
return false;
@ -208,7 +208,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
template<typename ForwardKey> void occupy_without_value(ForwardKey &&key, uint32_t UNUSED(hash))
{
BLI_assert(!this->is_occupied());
m_state = Occupied;
state_ = Occupied;
new ((void *)this->key()) Key(std::forward<ForwardKey>(key));
}
@ -219,7 +219,7 @@ template<typename Key, typename Value> class SimpleMapSlot {
void remove()
{
BLI_assert(this->is_occupied());
m_state = Removed;
state_ = Removed;
this->key()->~Key();
this->value()->~Value();
}
@ -235,61 +235,61 @@ template<typename Key, typename Value> class SimpleMapSlot {
*/
template<typename Key, typename Value, typename KeyInfo> class IntrusiveMapSlot {
private:
Key m_key = KeyInfo::get_empty();
AlignedBuffer<sizeof(Value), alignof(Value)> m_value_buffer;
Key key_ = KeyInfo::get_empty();
AlignedBuffer<sizeof(Value), alignof(Value)> value_buffer_;
public:
IntrusiveMapSlot() = default;
~IntrusiveMapSlot()
{
if (KeyInfo::is_not_empty_or_removed(m_key)) {
if (KeyInfo::is_not_empty_or_removed(key_)) {
this->value()->~Value();
}
}
IntrusiveMapSlot(const IntrusiveMapSlot &other) : m_key(other.m_key)
IntrusiveMapSlot(const IntrusiveMapSlot &other) : key_(other.key_)
{
if (KeyInfo::is_not_empty_or_removed(m_key)) {
if (KeyInfo::is_not_empty_or_removed(key_)) {
new ((void *)this->value()) Value(*other.value());
}
}
IntrusiveMapSlot(IntrusiveMapSlot &&other) noexcept : m_key(other.m_key)
IntrusiveMapSlot(IntrusiveMapSlot &&other) noexcept : key_(other.key_)
{
if (KeyInfo::is_not_empty_or_removed(m_key)) {
if (KeyInfo::is_not_empty_or_removed(key_)) {
new ((void *)this->value()) Value(std::move(*other.value()));
}
}
Key *key()
{
return &m_key;
return &key_;
}
const Key *key() const
{
return &m_key;
return &key_;
}
Value *value()
{
return (Value *)m_value_buffer.ptr();
return (Value *)value_buffer_.ptr();
}
const Value *value() const
{
return (const Value *)m_value_buffer.ptr();
return (const Value *)value_buffer_.ptr();
}
bool is_occupied() const
{
return KeyInfo::is_not_empty_or_removed(m_key);
return KeyInfo::is_not_empty_or_removed(key_);
}
bool is_empty() const
{
return KeyInfo::is_empty(m_key);
return KeyInfo::is_empty(key_);
}
template<typename Hash> uint32_t get_hash(const Hash &hash)
@ -302,9 +302,9 @@ template<typename Key, typename Value, typename KeyInfo> class IntrusiveMapSlot
{
BLI_assert(!this->is_occupied());
BLI_assert(other.is_occupied());
m_key = std::move(other.m_key);
key_ = std::move(other.key_);
new ((void *)this->value()) Value(std::move(*other.value()));
other.m_key.~Key();
other.key_.~Key();
other.value()->~Value();
}
@ -312,7 +312,7 @@ template<typename Key, typename Value, typename KeyInfo> class IntrusiveMapSlot
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint32_t UNUSED(hash)) const
{
BLI_assert(KeyInfo::is_not_empty_or_removed(key));
return is_equal(key, m_key);
return is_equal(key, key_);
}
template<typename ForwardKey, typename ForwardValue>
@ -328,13 +328,13 @@ template<typename Key, typename Value, typename KeyInfo> class IntrusiveMapSlot
{
BLI_assert(!this->is_occupied());
BLI_assert(KeyInfo::is_not_empty_or_removed(key));
m_key = std::forward<ForwardKey>(key);
key_ = std::forward<ForwardKey>(key);
}
void remove()
{
BLI_assert(this->is_occupied());
KeyInfo::remove(m_key);
KeyInfo::remove(key_);
this->value()->~Value();
}
};

6
source/blender/blenlib/BLI_memory_utils.hh
View File

@ -228,17 +228,17 @@ template<typename T> using destruct_ptr = std::unique_ptr<T, DestructValueAtAddr
template<size_t Size, size_t Alignment> class alignas(Alignment) AlignedBuffer {
private:
/* Don't create an empty array. This causes problems with some compilers. */
char m_buffer[(Size > 0) ? Size : 1];
char buffer_[(Size > 0) ? Size : 1];
public:
void *ptr()
{
return (void *)m_buffer;
return (void *)buffer_;
}
const void *ptr() const
{
return (const void *)m_buffer;
return (const void *)buffer_;
}
};

50
source/blender/blenlib/BLI_probing_strategies.hh
View File

@ -65,21 +65,21 @@ namespace blender {
*/
class LinearProbingStrategy {
private:
uint32_t m_hash;
uint32_t hash_;
public:
LinearProbingStrategy(uint32_t hash) : m_hash(hash)
LinearProbingStrategy(uint32_t hash) : hash_(hash)
{
}
void next()
{
m_hash++;
hash_++;
}
uint32_t get() const
{
return m_hash;
return hash_;
}
uint32_t linear_steps() const
@ -101,25 +101,25 @@ class LinearProbingStrategy {
*/
class QuadraticProbingStrategy {
private:
uint32_t m_original_hash;
uint32_t m_current_hash;
uint32_t m_iteration;
uint32_t original_hash_;
uint32_t current_hash_;
uint32_t iteration_;
public:
QuadraticProbingStrategy(uint32_t hash)
: m_original_hash(hash), m_current_hash(hash), m_iteration(1)
: original_hash_(hash), current_hash_(hash), iteration_(1)
{
}
void next()
{
m_current_hash = m_original_hash + ((m_iteration * m_iteration + m_iteration) >> 1);
m_iteration++;
current_hash_ = original_hash_ + ((iteration_ * iteration_ + iteration_) >> 1);
iteration_++;
}
uint32_t get() const
{
return m_current_hash;
return current_hash_;
}
uint32_t linear_steps() const
@ -140,11 +140,11 @@ class QuadraticProbingStrategy {
*/
template<uint32_t LinearSteps = 1, bool PreShuffle = false> class PythonProbingStrategy {
private:
uint32_t m_hash;
uint32_t m_perturb;
uint32_t hash_;
uint32_t perturb_;
public:
PythonProbingStrategy(uint32_t hash) : m_hash(hash), m_perturb(hash)
PythonProbingStrategy(uint32_t hash) : hash_(hash), perturb_(hash)
{
if (PreShuffle) {
this->next();
@ -153,13 +153,13 @@ template<uint32_t LinearSteps = 1, bool PreShuffle = false> class PythonProbingS
void next()
{
m_perturb >>= 5;
m_hash = 5 * m_hash + 1 + m_perturb;
perturb_ >>= 5;
hash_ = 5 * hash_ + 1 + perturb_;
}
uint32_t get() const
{
return m_hash;
return hash_;
}
uint32_t linear_steps() const
@ -175,11 +175,11 @@ template<uint32_t LinearSteps = 1, bool PreShuffle = false> class PythonProbingS
*/
template<uint32_t LinearSteps = 2, bool PreShuffle = false> class ShuffleProbingStrategy {
private:
uint32_t m_hash;
uint32_t m_perturb;
uint32_t hash_;
uint32_t perturb_;
public:
ShuffleProbingStrategy(uint32_t hash) : m_hash(hash), m_perturb(hash)
ShuffleProbingStrategy(uint32_t hash) : hash_(hash), perturb_(hash)
{
if (PreShuffle) {
this->next();
@ -188,18 +188,18 @@ template<uint32_t LinearSteps = 2, bool PreShuffle = false> class ShuffleProbing
void next()
{
if (m_perturb != 0) {
m_perturb >>= 10;
m_hash = ((m_hash >> 16) ^ m_hash) * 0x45d9f3b + m_perturb;
if (perturb_ != 0) {
perturb_ >>= 10;
hash_ = ((hash_ >> 16) ^ hash_) * 0x45d9f3b + perturb_;
}
else {
m_hash = 5 * m_hash + 1;
hash_ = 5 * hash_ + 1;
}
}
uint32_t get() const
{
return m_hash;
return hash_;
}
uint32_t linear_steps() const

178
source/blender/blenlib/BLI_set.hh
View File

@ -128,30 +128,30 @@ class Set {
* Slots are either empty, occupied or removed. The number of occupied slots can be computed by
* subtracting the removed slots from the occupied-and-removed slots.
*/
uint32_t m_removed_slots;
uint32_t m_occupied_and_removed_slots;
uint32_t removed_slots_;
uint32_t occupied_and_removed_slots_;
/**
* The maximum number of slots that can be used (either occupied or removed) until the set has to
* grow. This is the total number of slots times the max load factor.
*/
uint32_t m_usable_slots;
uint32_t usable_slots_;
/**
* The number of slots minus one. This is a bit mask that can be used to turn any integer into a
* valid slot index efficiently.
*/
uint32_t m_slot_mask;
uint32_t slot_mask_;
/** This is called to hash incoming keys. */
Hash m_hash;
Hash hash_;
/** This is called to check equality of two keys. */
IsEqual m_is_equal;
IsEqual is_equal_;
/** The max load factor is 1/2 = 50% by default. */
#define LOAD_FACTOR 1, 2
LoadFactor m_max_load_factor = LoadFactor(LOAD_FACTOR);
LoadFactor max_load_factor_ = LoadFactor(LOAD_FACTOR);
using SlotArray =
Array<Slot, LoadFactor::compute_total_slots(InlineBufferCapacity, LOAD_FACTOR), Allocator>;
#undef LOAD_FACTOR
@ -160,12 +160,12 @@ class Set {
* This is the array that contains the actual slots. There is always at least one empty slot and
* the size of the array is a power of two.
*/
SlotArray m_slots;
SlotArray slots_;
/** Iterate over a slot index sequence for a given hash. */
#define SET_SLOT_PROBING_BEGIN(HASH, R_SLOT) \
SLOT_PROBING_BEGIN (ProbingStrategy, HASH, m_slot_mask, SLOT_INDEX) \
auto &R_SLOT = m_slots[SLOT_INDEX];
SLOT_PROBING_BEGIN (ProbingStrategy, HASH, slot_mask_, SLOT_INDEX) \
auto &R_SLOT = slots_[SLOT_INDEX];
#define SET_SLOT_PROBING_END() SLOT_PROBING_END()
public:
@ -175,11 +175,11 @@ class Set {
* grow operation is performed on the first insertion.
*/
Set()
: m_removed_slots(0),
m_occupied_and_removed_slots(0),
m_usable_slots(0),
m_slot_mask(0),
m_slots(1)
: removed_slots_(0),
occupied_and_removed_slots_(0),
usable_slots_(0),
slot_mask_(0),
slots_(1)
{
}
@ -196,13 +196,13 @@ class Set {
Set(const Set &other) = default;
Set(Set &&other) noexcept
: m_removed_slots(other.m_removed_slots),
m_occupied_and_removed_slots(other.m_occupied_and_removed_slots),
m_usable_slots(other.m_usable_slots),
m_slot_mask(other.m_slot_mask),
m_hash(std::move(other.m_hash)),
m_is_equal(std::move(other.m_is_equal)),
m_slots(std::move(other.m_slots))
: removed_slots_(other.removed_slots_),
occupied_and_removed_slots_(other.occupied_and_removed_slots_),
usable_slots_(other.usable_slots_),
slot_mask_(other.slot_mask_),
hash_(std::move(other.hash_)),
is_equal_(std::move(other.is_equal_)),
slots_(std::move(other.slots_))
{
other.~Set();
new (&other) Set();
@ -239,11 +239,11 @@ class Set {
*/
void add_new(const Key &key)
{
this->add_new__impl(key, m_hash(key));
this->add_new__impl(key, hash_(key));
}
void add_new(Key &&key)
{
this->add_new__impl(std::move(key), m_hash(key));
this->add_new__impl(std::move(key), hash_(key));
}
/**
@ -266,7 +266,7 @@ class Set {
*/
template<typename ForwardKey> bool add_as(ForwardKey &&key)
{
return this->add__impl(std::forward<ForwardKey>(key), m_hash(key));
return this->add__impl(std::forward<ForwardKey>(key), hash_(key));
}
/**
@ -309,7 +309,7 @@ class Set {
*/
template<typename ForwardKey> bool contains_as(const ForwardKey &key) const
{
return this->contains__impl(key, m_hash(key));
return this->contains__impl(key, hash_(key));
}
/**
@ -327,7 +327,7 @@ class Set {
*/
template<typename ForwardKey> bool remove_as(const ForwardKey &key)
{
return this->remove__impl(key, m_hash(key));
return this->remove__impl(key, hash_(key));
}
/**
@ -344,7 +344,7 @@ class Set {
*/
template<typename ForwardKey> void remove_contained_as(const ForwardKey &key)
{
this->remove_contained__impl(key, m_hash(key));
this->remove_contained__impl(key, hash_(key));
}
/**
@ -356,20 +356,20 @@ class Set {
*/
class Iterator {
private:
const Slot *m_slots;
uint32_t m_total_slots;
uint32_t m_current_slot;
const Slot *slots_;
uint32_t total_slots_;
uint32_t current_slot_;
public:
Iterator(const Slot *slots, uint32_t total_slots, uint32_t current_slot)
: m_slots(slots), m_total_slots(total_slots), m_current_slot(current_slot)
: slots_(slots), total_slots_(total_slots), current_slot_(current_slot)
{
}
Iterator &operator++()
{
while (++m_current_slot < m_total_slots) {
if (m_slots[m_current_slot].is_occupied()) {
while (++current_slot_ < total_slots_) {
if (slots_[current_slot_].is_occupied()) {
break;
}
}
@ -378,22 +378,22 @@ class Set {
const Key &operator*() const
{
return *m_slots[m_current_slot].key();
return *slots_[current_slot_].key();
}
friend bool operator!=(const Iterator &a, const Iterator &b)
{
BLI_assert(a.m_slots == b.m_slots);
BLI_assert(a.m_total_slots == b.m_total_slots);
return a.m_current_slot != b.m_current_slot;
BLI_assert(a.slots_ == b.slots_);
BLI_assert(a.total_slots_ == b.total_slots_);
return a.current_slot_ != b.current_slot_;
}
};
Iterator begin() const
{
for (uint32_t i = 0; i < m_slots.size(); i++) {
if (m_slots[i].is_occupied()) {
return Iterator(m_slots.data(), m_slots.size(), i);
for (uint32_t i = 0; i < slots_.size(); i++) {
if (slots_[i].is_occupied()) {
return Iterator(slots_.data(), slots_.size(), i);
}
}
return this->end();
@ -401,7 +401,7 @@ class Set {
Iterator end() const
{
return Iterator(m_slots.data(), m_slots.size(), m_slots.size());
return Iterator(slots_.data(), slots_.size(), slots_.size());
}
/**
@ -419,7 +419,7 @@ class Set {
*/
uint32_t count_collisions(const Key &key) const
{
return this->count_collisions__impl(key, m_hash(key));
return this->count_collisions__impl(key, hash_(key));
}
/**
@ -445,7 +445,7 @@ class Set {
*/
uint32_t size() const
{
return m_occupied_and_removed_slots - m_removed_slots;
return occupied_and_removed_slots_ - removed_slots_;
}
/**
@ -453,7 +453,7 @@ class Set {
*/
bool is_empty() const
{
return m_occupied_and_removed_slots == m_removed_slots;
return occupied_and_removed_slots_ == removed_slots_;
}
/**
@ -461,7 +461,7 @@ class Set {
*/
uint32_t capacity() const
{
return m_slots.size();
return slots_.size();
}
/**
@ -469,7 +469,7 @@ class Set {
*/
uint32_t removed_amount() const
{
return m_removed_slots;
return removed_slots_;
}
/**
@ -486,7 +486,7 @@ class Set {
*/
uint32_t size_in_bytes() const
{
return sizeof(Slot) * m_slots.size();
return sizeof(Slot) * slots_.size();
}
/**
@ -495,7 +495,7 @@ class Set {
*/
void reserve(uint32_t n)
{
if (m_usable_slots < n) {
if (usable_slots_ < n) {
this->realloc_and_reinsert(n);
}
}
@ -530,7 +530,7 @@ class Set {
BLI_NOINLINE void realloc_and_reinsert(uint32_t min_usable_slots)
{
uint32_t total_slots, usable_slots;
m_max_load_factor.compute_total_and_usable_slots(
max_load_factor_.compute_total_and_usable_slots(
SlotArray::inline_buffer_capacity(), min_usable_slots, &total_slots, &usable_slots);
uint32_t new_slot_mask = total_slots - 1;
@ -538,19 +538,19 @@ class Set {
* Optimize the case when the set was empty beforehand. We can avoid some copies here.
*/
if (this->size() == 0) {
m_slots.~Array();
new (&m_slots) SlotArray(total_slots);
m_removed_slots = 0;
m_occupied_and_removed_slots = 0;
m_usable_slots = usable_slots;
m_slot_mask = new_slot_mask;
slots_.~Array();
new (&slots_) SlotArray(total_slots);
removed_slots_ = 0;
occupied_and_removed_slots_ = 0;
usable_slots_ = usable_slots;
slot_mask_ = new_slot_mask;
return;
}
/* The grown array that we insert the keys into. */
SlotArray new_slots(total_slots);
for (Slot &slot : m_slots) {
for (Slot &slot : slots_) {
if (slot.is_occupied()) {
this->add_after_grow_and_destruct_old(slot, new_slots, new_slot_mask);
}
@ -558,12 +558,12 @@ class Set {
/* All occupied slots have been destructed already and empty/removed slots are assumed to be
* trivially destructible. */
m_slots.clear_without_destruct();
m_slots = std::move(new_slots);
m_occupied_and_removed_slots -= m_removed_slots;
m_usable_slots = usable_slots;
m_removed_slots = 0;
m_slot_mask = new_slot_mask;
slots_.clear_without_destruct();
slots_ = std::move(new_slots);
occupied_and_removed_slots_ -= removed_slots_;
usable_slots_ = usable_slots;
removed_slots_ = 0;
slot_mask_ = new_slot_mask;
}
void add_after_grow_and_destruct_old(Slot &old_slot,
@ -588,7 +588,7 @@ class Set {
if (slot.is_empty()) {
return false;
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return true;
}
}
@ -604,7 +604,7 @@ class Set {
SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
slot.occupy(std::forward<ForwardKey>(key), hash);
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
return;
}
}
@ -618,10 +618,10 @@ class Set {
SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
slot.occupy(std::forward<ForwardKey>(key), hash);
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
return true;
}
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return false;
}
}
@ -631,9 +631,9 @@ class Set {
template<typename ForwardKey> bool remove__impl(const ForwardKey &key, uint32_t hash)
{
SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
slot.remove();
m_removed_slots++;
removed_slots_++;
return true;
}
if (slot.is_empty()) {
@ -646,10 +646,10 @@ class Set {
template<typename ForwardKey> void remove_contained__impl(const ForwardKey &key, uint32_t hash)
{
BLI_assert(this->contains_as(key));
m_removed_slots++;
removed_slots_++;
SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
slot.remove();
return;
}
@ -663,7 +663,7 @@ class Set {
uint32_t collisions = 0;
SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash)) {
if (slot.contains(key, is_equal_, hash)) {
return collisions;
}
if (slot.is_empty()) {
@ -676,9 +676,9 @@ class Set {
void ensure_can_add()
{
if (m_occupied_and_removed_slots >= m_usable_slots) {
if (occupied_and_removed_slots_ >= usable_slots_) {
this->realloc_and_reinsert(this->size() + 1);
BLI_assert(m_occupied_and_removed_slots < m_usable_slots);
BLI_assert(occupied_and_removed_slots_ < usable_slots_);
}
}
};
@ -690,77 +690,77 @@ class Set {
template<typename Key> class StdUnorderedSetWrapper {
private:
using SetType = std::unordered_set<Key, blender::DefaultHash<Key>>;
SetType m_set;
SetType set_;
public:
uint32_t size() const
{
return (uint32_t)m_set.size();
return (uint32_t)set_.size();
}
bool is_empty() const
{
return m_set.empty();
return set_.empty();
}
void reserve(uint32_t n)
{
m_set.reserve(n);
set_.reserve(n);
}
void add_new(const Key &key)
{
m_set.insert(key);
set_.insert(key);
}
void add_new(Key &&key)
{
m_set.insert(std::move(key));
set_.insert(std::move(key));
}
bool add(const Key &key)
{
return m_set.insert(key).second;
return set_.insert(key).second;
}
bool add(Key &&key)
{
return m_set.insert(std::move(key)).second;
return set_.insert(std::move(key)).second;
}
void add_multiple(Span<Key> keys)
{
for (const Key &key : keys) {
m_set.insert(key);
set_.insert(key);
}
}
bool contains(const Key &key) const
{
return m_set.find(key) != m_set.end();
return set_.find(key) != set_.end();
}
bool remove(const Key &key)
{
return (bool)m_set.erase(key);
return (bool)set_.erase(key);
}
void remove_contained(const Key &key)
{
return m_set.erase(key);
return set_.erase(key);
}
void clear()
{
m_set.clear();
set_.clear();
}
typename SetType::iterator begin() const
{
return m_set.begin();
return set_.begin();
}
typename SetType::iterator end() const
{
return m_set.end();
return set_.end();
}
};

102
source/blender/blenlib/BLI_set_slots.hh
View File

@ -50,8 +50,8 @@ template<typename Key> class SimpleSetSlot {
Removed = 2,
};
State m_state;
AlignedBuffer<sizeof(Key), alignof(Key)> m_buffer;
State state_;
AlignedBuffer<sizeof(Key), alignof(Key)> buffer_;
public:
/**
@ -59,7 +59,7 @@ template<typename Key> class SimpleSetSlot {
*/
SimpleSetSlot()
{
m_state = Empty;
state_ = Empty;
}
/**
@ -67,7 +67,7 @@ template<typename Key> class SimpleSetSlot {
*/
~SimpleSetSlot()
{
if (m_state == Occupied) {
if (state_ == Occupied) {
this->key()->~Key();
}
}
@ -78,8 +78,8 @@ template<typename Key> class SimpleSetSlot {
*/
SimpleSetSlot(const SimpleSetSlot &other)
{
m_state = other.m_state;
if (other.m_state == Occupied) {
state_ = other.state_;
if (other.state_ == Occupied) {
new ((void *)this->key()) Key(*other.key());
}
}
@ -91,8 +91,8 @@ template<typename Key> class SimpleSetSlot {
*/
SimpleSetSlot(SimpleSetSlot &&other) noexcept
{
m_state = other.m_state;
if (other.m_state == Occupied) {
state_ = other.state_;
if (other.state_ == Occupied) {
new ((void *)this->key()) Key(std::move(*other.key()));
}
}
@ -102,7 +102,7 @@ template<typename Key> class SimpleSetSlot {
*/
Key *key()
{
return (Key *)m_buffer.ptr();
return (Key *)buffer_.ptr();
}
/**
@ -110,7 +110,7 @@ template<typename Key> class SimpleSetSlot {
*/
const Key *key() const
{
return (const Key *)m_buffer.ptr();
return (const Key *)buffer_.ptr();
}
/**
@ -118,7 +118,7 @@ template<typename Key> class SimpleSetSlot {
*/
bool is_occupied() const
{
return m_state == Occupied;
return state_ == Occupied;
}
/**
@ -126,7 +126,7 @@ template<typename Key> class SimpleSetSlot {
*/
bool is_empty() const
{
return m_state == Empty;
return state_ == Empty;
}
/**
@ -147,7 +147,7 @@ template<typename Key> class SimpleSetSlot {
{
BLI_assert(!this->is_occupied());
BLI_assert(other.is_occupied());
m_state = Occupied;
state_ = Occupied;
new ((void *)this->key()) Key(std::move(*other.key()));
other.key()->~Key();
}
@ -159,7 +159,7 @@ template<typename Key> class SimpleSetSlot {
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint32_t UNUSED(hash)) const
{
if (m_state == Occupied) {
if (state_ == Occupied) {
return is_equal(key, *this->key());
}
return false;
@ -172,7 +172,7 @@ template<typename Key> class SimpleSetSlot {
template<typename ForwardKey> void occupy(ForwardKey &&key, uint32_t UNUSED(hash))
{
BLI_assert(!this->is_occupied());
m_state = Occupied;
state_ = Occupied;
new ((void *)this->key()) Key(std::forward<ForwardKey>(key));
}
@ -182,7 +182,7 @@ template<typename Key> class SimpleSetSlot {
void remove()
{
BLI_assert(this->is_occupied());
m_state = Removed;
state_ = Removed;
this->key()->~Key();
}
};
@ -199,73 +199,73 @@ template<typename Key> class HashedSetSlot {
Removed = 2,
};
uint32_t m_hash;
State m_state;
AlignedBuffer<sizeof(Key), alignof(Key)> m_buffer;
uint32_t hash_;
State state_;
AlignedBuffer<sizeof(Key), alignof(Key)> buffer_;
public:
HashedSetSlot()
{
m_state = Empty;
state_ = Empty;
}
~HashedSetSlot()
{
if (m_state == Occupied) {
if (state_ == Occupied) {
this->key()->~Key();
}
}
HashedSetSlot(const HashedSetSlot &other)
{
m_state = other.m_state;
if (other.m_state == Occupied) {
m_hash = other.m_hash;
state_ = other.state_;
if (other.state_ == Occupied) {
hash_ = other.hash_;
new ((void *)this->key()) Key(*other.key());
}
}
HashedSetSlot(HashedSetSlot &&other) noexcept
{
m_state = other.m_state;
if (other.m_state == Occupied) {
m_hash = other.m_hash;
state_ = other.state_;
if (other.state_ == Occupied) {
hash_ = other.hash_;
new ((void *)this->key()) Key(std::move(*other.key()));
}
}
Key *key()
{
return (Key *)m_buffer.ptr();
return (Key *)buffer_.ptr();
}
const Key *key() const
{
return (const Key *)m_buffer.ptr();
return (const Key *)buffer_.ptr();
}
bool is_occupied() const
{
return m_state == Occupied;
return state_ == Occupied;
}
bool is_empty() const
{
return m_state == Empty;
return state_ == Empty;
}
template<typename Hash> uint32_t get_hash(const Hash &UNUSED(hash)) const
{
BLI_assert(this->is_occupied());
return m_hash;
return hash_;
}
void relocate_occupied_here(HashedSetSlot &other, uint32_t hash)
{
BLI_assert(!this->is_occupied());
BLI_assert(other.is_occupied());
m_state = Occupied;
m_hash = hash;
state_ = Occupied;
hash_ = hash;
new ((void *)this->key()) Key(std::move(*other.key()));
other.key()->~Key();
}
@ -273,9 +273,9 @@ template<typename Key> class HashedSetSlot {
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint32_t hash) const
{
/* m_hash might be uninitialized here, but that is ok. */
if (m_hash == hash) {
if (m_state == Occupied) {
/* hash_ might be uninitialized here, but that is ok. */
if (hash_ == hash) {
if (state_ == Occupied) {
return is_equal(key, *this->key());
}
}
@ -285,15 +285,15 @@ template<typename Key> class HashedSetSlot {
template<typename ForwardKey> void occupy(ForwardKey &&key, uint32_t hash)
{
BLI_assert(!this->is_occupied());
m_state = Occupied;
m_hash = hash;
state_ = Occupied;
hash_ = hash;
new ((void *)this->key()) Key(std::forward<ForwardKey>(key));
}
void remove()
{
BLI_assert(this->is_occupied());
m_state = Removed;
state_ = Removed;
this->key()->~Key();
}
};
@ -308,7 +308,7 @@ template<typename Key> class HashedSetSlot {
*/
template<typename Key, typename KeyInfo> class IntrusiveSetSlot {
private:
Key m_key = KeyInfo::get_empty();
Key key_ = KeyInfo::get_empty();
public:
IntrusiveSetSlot() = default;
@ -318,43 +318,43 @@ template<typename Key, typename KeyInfo> class IntrusiveSetSlot {
Key *key()
{
return &m_key;
return &key_;
}
const Key *key() const
{
return &m_key;
return &key_;
}
bool is_occupied() const
{
return KeyInfo::is_not_empty_or_removed(m_key);
return KeyInfo::is_not_empty_or_removed(key_);
}
bool is_empty() const
{
return KeyInfo::is_empty(m_key);
return KeyInfo::is_empty(key_);
}
template<typename Hash> uint32_t get_hash(const Hash &hash) const
{
BLI_assert(this->is_occupied());
return hash(m_key);
return hash(key_);
}
void relocate_occupied_here(IntrusiveSetSlot &other, uint32_t UNUSED(hash))
{
BLI_assert(!this->is_occupied());
BLI_assert(other.is_occupied());
m_key = std::move(other.m_key);
other.m_key.~Key();
key_ = std::move(other.key_);
other.key_.~Key();
}
template<typename ForwardKey, typename IsEqual>
bool contains(const ForwardKey &key, const IsEqual &is_equal, uint32_t UNUSED(hash)) const
{
BLI_assert(KeyInfo::is_not_empty_or_removed(key));
return is_equal(m_key, key);
return is_equal(key_, key);
}
template<typename ForwardKey> void occupy(ForwardKey &&key, uint32_t UNUSED(hash))
@ -362,13 +362,13 @@ template<typename Key, typename KeyInfo> class IntrusiveSetSlot {
BLI_assert(!this->is_occupied());
BLI_assert(KeyInfo::is_not_empty_or_removed(key));
m_key = std::forward<ForwardKey>(key);
key_ = std::forward<ForwardKey>(key);
}
void remove()
{
BLI_assert(this->is_occupied());
KeyInfo::remove(m_key);
KeyInfo::remove(key_);
}
};

106
source/blender/blenlib/BLI_span.hh
View File

@ -87,8 +87,8 @@ namespace blender {
*/
template<typename T> class Span {
private:
const T *m_start = nullptr;
uint m_size = 0;
const T *start_ = nullptr;
uint size_ = 0;
public:
/**
@ -96,7 +96,7 @@ template<typename T> class Span {
*/
Span() = default;
Span(const T *start, uint size) : m_start(start), m_size(size)
Span(const T *start, uint size) : start_(start), size_(size)
{
}
@ -141,7 +141,7 @@ template<typename T> class Span {
Span slice(uint start, uint size) const
{
BLI_assert(start + size <= this->size() || size == 0);
return Span(m_start + start, size);
return Span(start_ + start, size);
}
Span slice(IndexRange range) const
@ -195,17 +195,17 @@ template<typename T> class Span {
*/
const T *data() const
{
return m_start;
return start_;
}
const T *begin() const
{
return m_start;
return start_;
}
const T *end() const
{
return m_start + m_size;
return start_ + size_;
}
/**
@ -214,8 +214,8 @@ template<typename T> class Span {
*/
const T &operator[](uint index) const
{
BLI_assert(index < m_size);
return m_start[index];
BLI_assert(index < size_);
return start_[index];
}
/**
@ -223,7 +223,7 @@ template<typename T> class Span {
*/
uint size() const
{
return m_size;
return size_;
}
/**
@ -231,7 +231,7 @@ template<typename T> class Span {
*/
bool is_empty() const
{
return m_size == 0;
return size_ == 0;
}
/**
@ -239,7 +239,7 @@ template<typename T> class Span {
*/
uint size_in_bytes() const
{
return sizeof(T) * m_size;
return sizeof(T) * size_;
}
/**
@ -286,8 +286,8 @@ template<typename T> class Span {
*/
const T &first() const
{
BLI_assert(m_size > 0);
return m_start[0];
BLI_assert(size_ > 0);
return start_[0];
}
/**
@ -296,8 +296,8 @@ template<typename T> class Span {
*/
const T &last() const
{
BLI_assert(m_size > 0);
return m_start[m_size - 1];
BLI_assert(size_ > 0);
return start_[size_ - 1];
}
/**
@ -306,8 +306,8 @@ template<typename T> class Span {
*/
T get(uint index, const T &fallback) const
{
if (index < m_size) {
return m_start[index];
if (index < size_) {
return start_[index];
}
return fallback;
}
@ -320,12 +320,12 @@ template<typename T> class Span {
{
/* The size should really be smaller than that. If it is not, the calling code should be
* changed. */
BLI_assert(m_size < 1000);
BLI_assert(size_ < 1000);
for (uint i = 0; i < m_size; i++) {
const T &value = m_start[i];
for (uint j = i + 1; j < m_size; j++) {
if (value == m_start[j]) {
for (uint i = 0; i < size_; i++) {
const T &value = start_[i];
for (uint j = i + 1; j < size_; j++) {
if (value == start_[j]) {
return true;
}
}
@ -342,10 +342,10 @@ template<typename T> class Span {
{
/* The size should really be smaller than that. If it is not, the calling code should be
* changed. */
BLI_assert(m_size < 1000);
BLI_assert(size_ < 1000);
for (uint i = 0; i < m_size; i++) {
const T &value = m_start[i];
for (uint i = 0; i < size_; i++) {
const T &value = start_[i];
if (other.contains(value)) {
return true;
}
@ -369,8 +369,8 @@ template<typename T> class Span {
*/
int first_index_try(const T &search_value) const
{
for (uint i = 0; i < m_size; i++) {
if (m_start[i] == search_value) {
for (uint i = 0; i < size_; i++) {
if (start_[i] == search_value) {
return i;
}
}
@ -383,7 +383,7 @@ template<typename T> class Span {
*/
IndexRange index_range() const
{
return IndexRange(m_size);
return IndexRange(size_);
}
/**
@ -391,9 +391,9 @@ template<typename T> class Span {
*/
template<typename NewT> Span<NewT> cast() const
{
BLI_assert((m_size * sizeof(T)) % sizeof(NewT) == 0);
uint new_size = m_size * sizeof(T) / sizeof(NewT);
return Span<NewT>(reinterpret_cast<const NewT *>(m_start), new_size);
BLI_assert((size_ * sizeof(T)) % sizeof(NewT) == 0);
uint new_size = size_ * sizeof(T) / sizeof(NewT);
return Span<NewT>(reinterpret_cast<const NewT *>(start_), new_size);
}
/**
@ -402,7 +402,7 @@ template<typename T> class Span {
*/
template<typename PrintLineF> void print_as_lines(std::string name, PrintLineF print_line) const
{
std::cout << "Span: " << name << " \tSize:" << m_size << '\n';
std::cout << "Span: " << name << " \tSize:" << size_ << '\n';
for (const T &value : *this) {
std::cout << " ";
print_line(value);
@ -426,13 +426,13 @@ template<typename T> class Span {
*/
template<typename T> class MutableSpan {
private:
T *m_start;
uint m_size;
T *start_;
uint size_;
public:
MutableSpan() = default;
MutableSpan(T *start, uint size) : m_start(start), m_size(size)
MutableSpan(T *start, uint size) : start_(start), size_(size)
{
}
@ -461,7 +461,7 @@ template<typename T> class MutableSpan {
operator Span<T>() const
{
return Span<T>(m_start, m_size);
return Span<T>(start_, size_);
}
/**
@ -469,7 +469,7 @@ template<typename T> class MutableSpan {
*/
uint size() const
{
return m_size;
return size_;
}
/**
@ -477,7 +477,7 @@ template<typename T> class MutableSpan {
*/
void fill(const T &value)
{
initialized_fill_n(m_start, m_size, value);
initialized_fill_n(start_, size_, value);
}
/**
@ -487,8 +487,8 @@ template<typename T> class MutableSpan {
void fill_indices(Span<uint> indices, const T &value)
{
for (uint i : indices) {
BLI_assert(i < m_size);
m_start[i] = value;
BLI_assert(i < size_);
start_[i] = value;
}
}
@ -498,23 +498,23 @@ template<typename T> class MutableSpan {
*/
T *data() const
{
return m_start;
return start_;
}
T *begin() const
{
return m_start;
return start_;
}
T *end() const
{
return m_start + m_size;
return start_ + size_;
}
T &operator[](uint index) const
{
BLI_assert(index < this->size());
return m_start[index];
return start_[index];
}
/**
@ -524,7 +524,7 @@ template<typename T> class MutableSpan {
MutableSpan slice(uint start, uint length) const
{
BLI_assert(start + length <= this->size());
return MutableSpan(m_start + start, length);
return MutableSpan(start_ + start, length);
}
/**
@ -573,7 +573,7 @@ template<typename T> class MutableSpan {
*/
Span<T> as_span() const
{
return Span<T>(m_start, m_size);
return Span<T>(start_, size_);
}
/**
@ -582,7 +582,7 @@ template<typename T> class MutableSpan {
*/
IndexRange index_range() const
{
return IndexRange(m_size);
return IndexRange(size_);
}
/**
@ -591,8 +591,8 @@ template<typename T> class MutableSpan {
*/
T &last() const
{
BLI_assert(m_size > 0);
return m_start[m_size - 1];
BLI_assert(size_ > 0);
return start_[size_ - 1];
}
/**
@ -600,9 +600,9 @@ template<typename T> class MutableSpan {
*/
template<typename NewT> MutableSpan<NewT> cast() const
{
BLI_assert((m_size * sizeof(T)) % sizeof(NewT) == 0);
uint new_size = m_size * sizeof(T) / sizeof(NewT);
return MutableSpan<NewT>(reinterpret_cast<NewT *>(m_start), new_size);
BLI_assert((size_ * sizeof(T)) % sizeof(NewT) == 0);
uint new_size = size_ * sizeof(T) / sizeof(NewT);
return MutableSpan<NewT>(reinterpret_cast<NewT *>(start_), new_size);
}
};

165
source/blender/blenlib/BLI_stack.hh
View File

@ -91,48 +91,48 @@ class Stack {
* Points to one element after top-most value in the stack.
*
* Invariant:
* If m_size == 0
* then: m_top == m_inline_chunk.begin
* else: &peek() == m_top - 1;
* If size_ == 0
* then: top_ == inline_chunk_.begin
* else: &peek() == top_ - 1;
*/
T *m_top;
T *top_;
/** Points to the chunk that references the memory pointed to by m_top. */
Chunk *m_top_chunk;
/** Points to the chunk that references the memory pointed to by top_. */
Chunk *top_chunk_;
/**
* Number of elements in the entire stack. The sum of initialized element counts in the chunks.
*/
uint m_size;
uint size_;
/** The buffer used to implement small object optimization. */
AlignedBuffer<sizeof(T) * InlineBufferCapacity, alignof(T)> m_inline_buffer;
AlignedBuffer<sizeof(T) * InlineBufferCapacity, alignof(T)> inline_buffer_;
/**
* A chunk referencing the inline buffer. This is always the bottom-most chunk.
* So m_inline_chunk.below == nullptr.
* So inline_chunk_.below == nullptr.
*/
Chunk m_inline_chunk;
Chunk inline_chunk_;
/** Used for allocations when the inline buffer is not large enough. */
Allocator m_allocator;
Allocator allocator_;
public:
/**
* Initialize an empty stack. No heap allocation is done.
*/
Stack(Allocator allocator = {}) : m_allocator(allocator)
Stack(Allocator allocator = {}) : allocator_(allocator)
{
T *inline_buffer = this->inline_buffer();
m_inline_chunk.below = nullptr;
m_inline_chunk.above = nullptr;
m_inline_chunk.begin = inline_buffer;
m_inline_chunk.capacity_end = inline_buffer + InlineBufferCapacity;
inline_chunk_.below = nullptr;
inline_chunk_.above = nullptr;
inline_chunk_.begin = inline_buffer;
inline_chunk_.capacity_end = inline_buffer + InlineBufferCapacity;
m_top = inline_buffer;
m_top_chunk = &m_inline_chunk;
m_size = 0;
top_ = inline_buffer;
top_chunk_ = &inline_chunk_;
size_ = 0;
}
/**
@ -157,46 +157,45 @@ class Stack {
{
}
Stack(const Stack &other) : Stack(other.m_allocator)
Stack(const Stack &other) : Stack(other.allocator_)
{
for (const Chunk *chunk = &other.m_inline_chunk; chunk; chunk = chunk->above) {
for (const Chunk *chunk = &other.inline_chunk_; chunk; chunk = chunk->above) {
const T *begin = chunk->begin;
const T *end = (chunk == other.m_top_chunk) ? other.m_top : chunk->capacity_end;
const T *end = (chunk == other.top_chunk_) ? other.top_ : chunk->capacity_end;
this->push_multiple(Span<T>(begin, end - begin));
}
}
Stack(Stack &&other) noexcept : Stack(other.m_allocator)
Stack(Stack &&other) noexcept : Stack(other.allocator_)
{
uninitialized_relocate_n(other.inline_buffer(),
std::min(other.m_size, InlineBufferCapacity),
this->inline_buffer());
uninitialized_relocate_n(
other.inline_buffer(), std::min(other.size_, InlineBufferCapacity), this->inline_buffer());
m_inline_chunk.above = other.m_inline_chunk.above;
m_size = other.m_size;
inline_chunk_.above = other.inline_chunk_.above;
size_ = other.size_;
if (m_size <= InlineBufferCapacity) {
m_top_chunk = &m_inline_chunk;
m_top = this->inline_buffer() + m_size;
if (size_ <= InlineBufferCapacity) {
top_chunk_ = &inline_chunk_;
top_ = this->inline_buffer() + size_;
}
else {
m_top_chunk = other.m_top_chunk;
m_top = other.m_top;
top_chunk_ = other.top_chunk_;
top_ = other.top_;
}
other.m_size = 0;
other.m_inline_chunk.above = nullptr;
other.m_top_chunk = &other.m_inline_chunk;
other.m_top = other.m_top_chunk->begin;
other.size_ = 0;
other.inline_chunk_.above = nullptr;
other.top_chunk_ = &other.inline_chunk_;
other.top_ = other.top_chunk_->begin;
}
~Stack()
{
this->destruct_all_elements();
Chunk *above_chunk;
for (Chunk *chunk = m_inline_chunk.above; chunk; chunk = above_chunk) {
for (Chunk *chunk = inline_chunk_.above; chunk; chunk = above_chunk) {
above_chunk = chunk->above;
m_allocator.deallocate(chunk);
allocator_.deallocate(chunk);
}
}
@ -229,21 +228,21 @@ class Stack {
*/
void push(const T &value)
{
if (m_top == m_top_chunk->capacity_end) {
if (top_ == top_chunk_->capacity_end) {
this->activate_next_chunk(1);
}
new (m_top) T(value);
m_top++;
m_size++;
new (top_) T(value);
top_++;
size_++;
}
void push(T &&value)
{
if (m_top == m_top_chunk->capacity_end) {
if (top_ == top_chunk_->capacity_end) {
this->activate_next_chunk(1);
}
new (m_top) T(std::move(value));
m_top++;
m_size++;
new (top_) T(std::move(value));
top_++;
size_++;
}
/**
@ -252,16 +251,16 @@ class Stack {
*/
T pop()
{
BLI_assert(m_size > 0);
m_top--;
T value = std::move(*m_top);
m_top->~T();
m_size--;
BLI_assert(size_ > 0);
top_--;
T value = std::move(*top_);
top_->~T();
size_--;
if (m_top == m_top_chunk->begin) {
if (m_top_chunk->below != nullptr) {
m_top_chunk = m_top_chunk->below;
m_top = m_top_chunk->capacity_end;
if (top_ == top_chunk_->begin) {
if (top_chunk_->below != nullptr) {
top_chunk_ = top_chunk_->below;
top_ = top_chunk_->capacity_end;
}
}
return value;
@ -273,15 +272,15 @@ class Stack {
*/
T &peek()
{
BLI_assert(m_size > 0);
BLI_assert(m_top > m_top_chunk->begin);
return *(m_top - 1);
BLI_assert(size_ > 0);
BLI_assert(top_ > top_chunk_->begin);
return *(top_ - 1);
}
const T &peek() const
{
BLI_assert(m_size > 0);
BLI_assert(m_top > m_top_chunk->begin);
return *(m_top - 1);
BLI_assert(size_ > 0);
BLI_assert(top_ > top_chunk_->begin);
return *(top_ - 1);
}
/**
@ -293,19 +292,19 @@ class Stack {
{
Span<T> remaining_values = values;
while (!remaining_values.is_empty()) {
if (m_top == m_top_chunk->capacity_end) {
if (top_ == top_chunk_->capacity_end) {
this->activate_next_chunk(remaining_values.size());
}
uint remaining_capacity = m_top_chunk->capacity_end - m_top;
uint remaining_capacity = top_chunk_->capacity_end - top_;
uint amount = std::min(remaining_values.size(), remaining_capacity);
uninitialized_copy_n(remaining_values.data(), amount, m_top);
m_top += amount;
uninitialized_copy_n(remaining_values.data(), amount, top_);
top_ += amount;
remaining_values = remaining_values.drop_front(amount);
}
m_size += values.size();
size_ += values.size();
}
/**
@ -313,7 +312,7 @@ class Stack {
*/
bool is_empty() const
{
return m_size == 0;
return size_ == 0;
}
/**
@ -321,7 +320,7 @@ class Stack {
*/
uint size() const
{
return m_size;
return size_;
}
/**
@ -331,18 +330,18 @@ class Stack {
void clear()
{
this->destruct_all_elements();
m_top_chunk = &m_inline_chunk;
m_top = m_top_chunk->begin;
top_chunk_ = &inline_chunk_;
top_ = top_chunk_->begin;
}
private:
T *inline_buffer() const
{
return (T *)m_inline_buffer.ptr();
return (T *)inline_buffer_.ptr();
}
/**
* Changes m_top_chunk to point to a new chunk that is above the current one. The new chunk might
* Changes top_chunk_ to point to a new chunk that is above the current one. The new chunk might
* be smaller than the given size_hint. This happens when a chunk that has been allocated before
* is reused. The size of the new chunk will be at least one.
*
@ -350,12 +349,12 @@ class Stack {
*/
void activate_next_chunk(uint size_hint)
{
BLI_assert(m_top == m_top_chunk->capacity_end);
if (m_top_chunk->above == nullptr) {
uint new_capacity = std::max(size_hint, m_top_chunk->capacity() * 2 + 10);
BLI_assert(top_ == top_chunk_->capacity_end);
if (top_chunk_->above == nullptr) {
uint new_capacity = std::max(size_hint, top_chunk_->capacity() * 2 + 10);
/* Do a single memory allocation for the Chunk and the array it references. */
void *buffer = m_allocator.allocate(
void *buffer = allocator_.allocate(
sizeof(Chunk) + sizeof(T) * new_capacity + alignof(T), alignof(Chunk), AT);
void *chunk_buffer = buffer;
void *data_buffer = (void *)(((uintptr_t)buffer + sizeof(Chunk) + alignof(T) - 1) &
@ -365,19 +364,19 @@ class Stack {
new_chunk->begin = (T *)data_buffer;
new_chunk->capacity_end = new_chunk->begin + new_capacity;
new_chunk->above = nullptr;
new_chunk->below = m_top_chunk;
m_top_chunk->above = new_chunk;
new_chunk->below = top_chunk_;
top_chunk_->above = new_chunk;
}
m_top_chunk = m_top_chunk->above;
m_top = m_top_chunk->begin;
top_chunk_ = top_chunk_->above;
top_ = top_chunk_->begin;
}
void destruct_all_elements()
{
for (T *value = m_top_chunk->begin; value != m_top; value++) {
for (T *value = top_chunk_->begin; value != top_; value++) {
value->~T();
}
for (Chunk *chunk = m_top_chunk->below; chunk; chunk = chunk->below) {
for (Chunk *chunk = top_chunk_->below; chunk; chunk = chunk->below) {
for (T *value = chunk->begin; value != chunk->capacity_end; value++) {
value->~T();
}

56
source/blender/blenlib/BLI_string_ref.hh
View File

@ -59,10 +59,10 @@ class StringRef;
*/
class StringRefBase {
protected:
const char *m_data;
uint m_size;
const char *data_;
uint size_;
StringRefBase(const char *data, uint size) : m_data(data), m_size(size)
StringRefBase(const char *data, uint size) : data_(data), size_(size)
{
}
@ -72,7 +72,7 @@ class StringRefBase {
*/
uint size() const
{
return m_size;
return size_;
}
/**
@ -80,12 +80,12 @@ class StringRefBase {
*/
const char *data() const
{
return m_data;
return data_;
}
operator Span<char>() const
{
return Span<char>(m_data, m_size);
return Span<char>(data_, size_);
}
/**
@ -94,17 +94,17 @@ class StringRefBase {
*/
operator std::string() const
{
return std::string(m_data, m_size);
return std::string(data_, size_);
}
const char *begin() const
{
return m_data;
return data_;
}
const char *end() const
{
return m_data + m_size;
return data_ + size_;
}
/**
@ -114,8 +114,8 @@ class StringRefBase {
*/
void unsafe_copy(char *dst) const
{
memcpy(dst, m_data, m_size);
dst[m_size] = '\0';
memcpy(dst, data_, size_);
dst[size_] = '\0';
}
/**
@ -124,7 +124,7 @@ class StringRefBase {
*/
void copy(char *dst, uint dst_size) const
{
if (m_size < dst_size) {
if (size_ < dst_size) {
this->unsafe_copy(dst);
}
else {
@ -171,7 +171,7 @@ class StringRefNull : public StringRefBase {
StringRefNull(const char *str) : StringRefBase(str, (uint)strlen(str))
{
BLI_assert(str != NULL);
BLI_assert(m_data[m_size] == '\0');
BLI_assert(data_[size_] == '\0');
}
/**
@ -197,8 +197,8 @@ class StringRefNull : public StringRefBase {
char operator[](uint index) const
{
/* Use '<=' instead of just '<', so that the null character can be accessed as well. */
BLI_assert(index <= m_size);
return m_data[index];
BLI_assert(index <= size_);
return data_[index];
}
};
@ -252,8 +252,8 @@ class StringRef : public StringRefBase {
*/
StringRef drop_prefix(uint n) const
{
BLI_assert(n <= m_size);
return StringRef(m_data + n, m_size - n);
BLI_assert(n <= size_);
return StringRef(data_ + n, size_ - n);
}
/**
@ -271,8 +271,8 @@ class StringRef : public StringRefBase {
*/
char operator[](uint index) const
{
BLI_assert(index < m_size);
return m_data[index];
BLI_assert(index < size_);
return data_[index];
}
};
@ -318,11 +318,11 @@ inline bool operator!=(StringRef a, StringRef b)
*/
inline bool StringRefBase::startswith(StringRef prefix) const
{
if (m_size < prefix.m_size) {
if (size_ < prefix.size_) {
return false;
}
for (uint i = 0; i < prefix.m_size; i++) {
if (m_data[i] != prefix.m_data[i]) {
for (uint i = 0; i < prefix.size_; i++) {
if (data_[i] != prefix.data_[i]) {
return false;
}
}
@ -334,12 +334,12 @@ inline bool StringRefBase::startswith(StringRef prefix) const
*/
inline bool StringRefBase::endswith(StringRef suffix) const
{
if (m_size < suffix.m_size) {
if (size_ < suffix.size_) {
return false;
}
uint offset = m_size - suffix.m_size;
for (uint i = 0; i < suffix.m_size; i++) {
if (m_data[offset + i] != suffix.m_data[i]) {
uint offset = size_ - suffix.size_;
for (uint i = 0; i < suffix.size_; i++) {
if (data_[offset + i] != suffix.data_[i]) {
return false;
}
}
@ -351,8 +351,8 @@ inline bool StringRefBase::endswith(StringRef suffix) const
*/
inline StringRef StringRefBase::substr(uint start, uint size) const
{
BLI_assert(start + size <= m_size);
return StringRef(m_data + start, size);
BLI_assert(start + size <= size_);
return StringRef(data_ + start, size);
}
} // namespace blender

12
source/blender/blenlib/BLI_timeit.hh
View File

@ -34,21 +34,21 @@ void print_duration(Nanoseconds duration);
class ScopedTimer {
private:
std::string m_name;
TimePoint m_start;
std::string name_;
TimePoint start_;
public:
ScopedTimer(std::string name) : m_name(std::move(name))
ScopedTimer(std::string name) : name_(std::move(name))
{
m_start = Clock::now();
start_ = Clock::now();
}
~ScopedTimer()
{
TimePoint end = Clock::now();
Nanoseconds duration = end - m_start;
Nanoseconds duration = end - start_;
std::cout << "Timer '" << m_name << "' took ";
std::cout << "Timer '" << name_ << "' took ";
print_duration(duration);
std::cout << '\n';
}

210
source/blender/blenlib/BLI_vector.hh
View File

@ -84,15 +84,15 @@ class Vector {
*
* The pointers might point to the memory in the inline buffer.
*/
T *m_begin;
T *m_end;
T *m_capacity_end;
T *begin_;
T *end_;
T *capacity_end_;
/** Used for allocations when the inline buffer is too small. */
Allocator m_allocator;
Allocator allocator_;
/** A placeholder buffer that will remain uninitialized until it is used. */
AlignedBuffer<(uint)sizeof(T) * InlineBufferCapacity, (uint)alignof(T)> m_inline_buffer;
AlignedBuffer<(uint)sizeof(T) * InlineBufferCapacity, (uint)alignof(T)> inline_buffer_;
/**
* Store the size of the vector explicitly in debug builds. Otherwise you'd always have to call
@ -100,8 +100,8 @@ class Vector {
* annoying. Knowing the size of a vector is often quite essential when debugging some code.
*/
#ifndef NDEBUG
uint m_debug_size;
# define UPDATE_VECTOR_SIZE(ptr) (ptr)->m_debug_size = (uint)((ptr)->m_end - (ptr)->m_begin)
uint debug_size_;
# define UPDATE_VECTOR_SIZE(ptr) (ptr)->debug_size_ = (uint)((ptr)->end_ - (ptr)->begin_)
#else
# define UPDATE_VECTOR_SIZE(ptr) ((void)0)
#endif
@ -120,9 +120,9 @@ class Vector {
*/
Vector()
{
m_begin = this->inline_buffer();
m_end = m_begin;
m_capacity_end = m_begin + InlineBufferCapacity;
begin_ = this->inline_buffer();
end_ = begin_;
capacity_end_ = begin_ + InlineBufferCapacity;
UPDATE_VECTOR_SIZE(this);
}
@ -143,7 +143,7 @@ class Vector {
{
this->reserve(size);
this->increase_size_by_unchecked(size);
blender::uninitialized_fill_n(m_begin, size, value);
blender::uninitialized_fill_n(begin_, size, value);
}
/**
@ -164,7 +164,7 @@ class Vector {
uint size = values.size();
this->reserve(size);
this->increase_size_by_unchecked(size);
blender::uninitialized_copy_n(values.data(), size, m_begin);
blender::uninitialized_copy_n(values.data(), size, begin_);
}
/**
@ -198,7 +198,7 @@ class Vector {
* Create a copy of another vector. The other vector will not be changed. If the other vector has
* less than InlineBufferCapacity elements, no allocation will be made.
*/
Vector(const Vector &other) : m_allocator(other.m_allocator)
Vector(const Vector &other) : allocator_(other.allocator_)
{
this->init_copy_from_other_vector(other);
}
@ -209,7 +209,7 @@ class Vector {
*/
template<uint OtherInlineBufferCapacity>
Vector(const Vector<T, OtherInlineBufferCapacity, Allocator> &other)
: m_allocator(other.m_allocator)
: allocator_(other.allocator_)
{
this->init_copy_from_other_vector(other);
}
@ -220,57 +220,57 @@ class Vector {
*/
template<uint OtherInlineBufferCapacity>
Vector(Vector<T, OtherInlineBufferCapacity, Allocator> &&other) noexcept
: m_allocator(other.m_allocator)
: allocator_(other.allocator_)
{
uint size = other.size();
if (other.is_inline()) {
if (size <= InlineBufferCapacity) {
/* Copy between inline buffers. */
m_begin = this->inline_buffer();
m_end = m_begin + size;
m_capacity_end = m_begin + InlineBufferCapacity;
uninitialized_relocate_n(other.m_begin, size, m_begin);
begin_ = this->inline_buffer();
end_ = begin_ + size;
capacity_end_ = begin_ + InlineBufferCapacity;
uninitialized_relocate_n(other.begin_, size, begin_);
}
else {
/* Copy from inline buffer to newly allocated buffer. */
uint capacity = size;
m_begin = (T *)m_allocator.allocate(sizeof(T) * capacity, alignof(T), AT);
m_end = m_begin + size;
m_capacity_end = m_begin + capacity;
uninitialized_relocate_n(other.m_begin, size, m_begin);
begin_ = (T *)allocator_.allocate(sizeof(T) * capacity, alignof(T), AT);
end_ = begin_ + size;
capacity_end_ = begin_ + capacity;
uninitialized_relocate_n(other.begin_, size, begin_);
}
}
else {
/* Steal the pointer. */
m_begin = other.m_begin;
m_end = other.m_end;
m_capacity_end = other.m_capacity_end;
begin_ = other.begin_;
end_ = other.end_;
capacity_end_ = other.capacity_end_;
}
other.m_begin = other.inline_buffer();
other.m_end = other.m_begin;
other.m_capacity_end = other.m_begin + OtherInlineBufferCapacity;
other.begin_ = other.inline_buffer();
other.end_ = other.begin_;
other.capacity_end_ = other.begin_ + OtherInlineBufferCapacity;
UPDATE_VECTOR_SIZE(this);
UPDATE_VECTOR_SIZE(&other);
}
~Vector()
{
destruct_n(m_begin, this->size());
destruct_n(begin_, this->size());
if (!this->is_inline()) {
m_allocator.deallocate(m_begin);
allocator_.deallocate(begin_);
}
}
operator Span<T>() const
{
return Span<T>(m_begin, this->size());
return Span<T>(begin_, this->size());
}
operator MutableSpan<T>()
{
return MutableSpan<T>(m_begin, this->size());
return MutableSpan<T>(begin_, this->size());
}
Span<T> as_span() const
@ -332,12 +332,12 @@ class Vector {
uint old_size = this->size();
if (new_size > old_size) {
this->reserve(new_size);
default_construct_n(m_begin + old_size, new_size - old_size);
default_construct_n(begin_ + old_size, new_size - old_size);
}
else {
destruct_n(m_begin + new_size, old_size - new_size);
destruct_n(begin_ + new_size, old_size - new_size);
}
m_end = m_begin + new_size;
end_ = begin_ + new_size;
UPDATE_VECTOR_SIZE(this);
}
@ -352,12 +352,12 @@ class Vector {
uint old_size = this->size();
if (new_size > old_size) {
this->reserve(new_size);
uninitialized_fill_n(m_begin + old_size, new_size - old_size, value);
uninitialized_fill_n(begin_ + old_size, new_size - old_size, value);
}
else {
destruct_n(m_begin + new_size, old_size - new_size);
destruct_n(begin_ + new_size, old_size - new_size);
}
m_end = m_begin + new_size;
end_ = begin_ + new_size;
UPDATE_VECTOR_SIZE(this);
}
@ -367,8 +367,8 @@ class Vector {
*/
void clear()
{
destruct_n(m_begin, this->size());
m_end = m_begin;
destruct_n(begin_, this->size());
end_ = begin_;
UPDATE_VECTOR_SIZE(this);
}
@ -378,14 +378,14 @@ class Vector {
*/
void clear_and_make_inline()
{
destruct_n(m_begin, this->size());
destruct_n(begin_, this->size());
if (!this->is_inline()) {
m_allocator.deallocate(m_begin);
allocator_.deallocate(begin_);
}
m_begin = this->inline_buffer();
m_end = m_begin;
m_capacity_end = m_begin + InlineBufferCapacity;
begin_ = this->inline_buffer();
end_ = begin_;
capacity_end_ = begin_ + InlineBufferCapacity;
UPDATE_VECTOR_SIZE(this);
}
@ -436,16 +436,16 @@ class Vector {
*/
void append_unchecked(const T &value)
{
BLI_assert(m_end < m_capacity_end);
new (m_end) T(value);
m_end++;
BLI_assert(end_ < capacity_end_);
new (end_) T(value);
end_++;
UPDATE_VECTOR_SIZE(this);
}
void append_unchecked(T &&value)
{
BLI_assert(m_end < m_capacity_end);
new (m_end) T(std::move(value));
m_end++;
BLI_assert(end_ < capacity_end_);
new (end_) T(std::move(value));
end_++;
UPDATE_VECTOR_SIZE(this);
}
@ -456,7 +456,7 @@ class Vector {
void append_n_times(const T &value, uint n)
{
this->reserve(this->size() + n);
blender::uninitialized_fill_n(m_end, n, value);
blender::uninitialized_fill_n(end_, n, value);
this->increase_size_by_unchecked(n);
}
@ -468,8 +468,8 @@ class Vector {
*/
void increase_size_by_unchecked(uint n)
{
BLI_assert(m_end + n <= m_capacity_end);
m_end += n;
BLI_assert(end_ + n <= capacity_end_);
end_ += n;
UPDATE_VECTOR_SIZE(this);
}
@ -510,9 +510,9 @@ class Vector {
}
void extend_unchecked(const T *start, uint amount)
{
BLI_assert(m_begin + amount <= m_capacity_end);
blender::uninitialized_copy_n(start, amount, m_end);
m_end += amount;
BLI_assert(begin_ + amount <= capacity_end_);
blender::uninitialized_copy_n(start, amount, end_);
end_ += amount;
UPDATE_VECTOR_SIZE(this);
}
@ -523,12 +523,12 @@ class Vector {
const T &last() const
{
BLI_assert(this->size() > 0);
return *(m_end - 1);
return *(end_ - 1);
}
T &last()
{
BLI_assert(this->size() > 0);
return *(m_end - 1);
return *(end_ - 1);
}
/**
@ -536,7 +536,7 @@ class Vector {
*/
void fill(const T &value)
{
initialized_fill_n(m_begin, this->size(), value);
initialized_fill_n(begin_, this->size(), value);
}
/**
@ -552,8 +552,8 @@ class Vector {
*/
uint size() const
{
BLI_assert(m_debug_size == (uint)(m_end - m_begin));
return (uint)(m_end - m_begin);
BLI_assert(debug_size_ == (uint)(end_ - begin_));
return (uint)(end_ - begin_);
}
/**
@ -563,7 +563,7 @@ class Vector {
*/
bool is_empty() const
{
return m_begin == m_end;
return begin_ == end_;
}
/**
@ -573,8 +573,8 @@ class Vector {
void remove_last()
{
BLI_assert(!this->is_empty());
m_end--;
m_end->~T();
end_--;
end_->~T();
UPDATE_VECTOR_SIZE(this);
}
@ -587,9 +587,9 @@ class Vector {
T pop_last()
{
BLI_assert(!this->is_empty());
m_end--;
T value = std::move(*m_end);
m_end->~T();
end_--;
T value = std::move(*end_);
end_->~T();
UPDATE_VECTOR_SIZE(this);
return value;
}
@ -601,12 +601,12 @@ class Vector {
void remove_and_reorder(uint index)
{
BLI_assert(index < this->size());
T *element_to_remove = m_begin + index;
m_end--;
if (element_to_remove < m_end) {
*element_to_remove = std::move(*m_end);
T *element_to_remove = begin_ + index;
end_--;
if (element_to_remove < end_) {
*element_to_remove = std::move(*end_);
}
m_end->~T();
end_->~T();
UPDATE_VECTOR_SIZE(this);
}
@ -632,10 +632,10 @@ class Vector {
BLI_assert(index < this->size());
uint last_index = this->size() - 1;
for (uint i = index; i < last_index; i++) {
m_begin[i] = std::move(m_begin[i + 1]);
begin_[i] = std::move(begin_[i + 1]);
}
m_begin[last_index].~T();
m_end--;
begin_[last_index].~T();
end_--;
UPDATE_VECTOR_SIZE(this);
}
@ -645,9 +645,9 @@ class Vector {
*/
int first_index_of_try(const T &value) const
{
for (T *current = m_begin; current != m_end; current++) {
for (T *current = begin_; current != end_; current++) {
if (*current == value) {
return (int)(current - m_begin);
return (int)(current - begin_);
}
}
return -1;
@ -680,13 +680,13 @@ class Vector {
const T &operator[](uint index) const
{
BLI_assert(index < this->size());
return m_begin[index];
return begin_[index];
}
T &operator[](uint index)
{
BLI_assert(index < this->size());
return m_begin[index];
return begin_[index];
}
/**
@ -694,7 +694,7 @@ class Vector {
*/
T *data()
{
return m_begin;
return begin_;
}
/**
@ -702,25 +702,25 @@ class Vector {
*/
const T *data() const
{
return m_begin;
return begin_;
}
T *begin()
{
return m_begin;
return begin_;
}
T *end()
{
return m_end;
return end_;
}
const T *begin() const
{
return m_begin;
return begin_;
}
const T *end() const
{
return m_end;
return end_;
}
/**
@ -729,7 +729,7 @@ class Vector {
*/
uint capacity() const
{
return (uint)(m_capacity_end - m_begin);
return (uint)(capacity_end_ - begin_);
}
/**
@ -754,7 +754,7 @@ class Vector {
std::cout << "Vector Stats: " << name << "\n";
std::cout << " Address: " << this << "\n";
std::cout << " Elements: " << this->size() << "\n";
std::cout << " Capacity: " << (m_capacity_end - m_begin) << "\n";
std::cout << " Capacity: " << (capacity_end_ - begin_) << "\n";
std::cout << " Inline Capacity: " << InlineBufferCapacity << "\n";
char memory_size_str[15];
@ -765,17 +765,17 @@ class Vector {
private:
T *inline_buffer() const
{
return (T *)m_inline_buffer.ptr();
return (T *)inline_buffer_.ptr();
}
bool is_inline() const
{
return m_begin == this->inline_buffer();
return begin_ == this->inline_buffer();
}
void ensure_space_for_one()
{
if (UNLIKELY(m_end >= m_capacity_end)) {
if (UNLIKELY(end_ >= capacity_end_)) {
this->realloc_to_at_least(this->size() + 1);
}
}
@ -793,42 +793,42 @@ class Vector {
uint new_capacity = std::max(min_capacity, min_new_capacity);
uint size = this->size();
T *new_array = (T *)m_allocator.allocate(new_capacity * (uint)sizeof(T), alignof(T), AT);
uninitialized_relocate_n(m_begin, size, new_array);
T *new_array = (T *)allocator_.allocate(new_capacity * (uint)sizeof(T), alignof(T), AT);
uninitialized_relocate_n(begin_, size, new_array);
if (!this->is_inline()) {
m_allocator.deallocate(m_begin);
allocator_.deallocate(begin_);
}
m_begin = new_array;
m_end = m_begin + size;
m_capacity_end = m_begin + new_capacity;
begin_ = new_array;
end_ = begin_ + size;
capacity_end_ = begin_ + new_capacity;
}
/**
* Initialize all properties, except for m_allocator, which has to be initialized beforehand.
* Initialize all properties, except for allocator_, which has to be initialized beforehand.
*/
template<uint OtherInlineBufferCapacity>
void init_copy_from_other_vector(const Vector<T, OtherInlineBufferCapacity, Allocator> &other)
{
m_allocator = other.m_allocator;
allocator_ = other.allocator_;
uint size = other.size();
uint capacity = size;
if (size <= InlineBufferCapacity) {
m_begin = this->inline_buffer();
begin_ = this->inline_buffer();
capacity = InlineBufferCapacity;
}
else {
m_begin = (T *)m_allocator.allocate(sizeof(T) * size, alignof(T), AT);
begin_ = (T *)allocator_.allocate(sizeof(T) * size, alignof(T), AT);
capacity = size;
}
m_end = m_begin + size;
m_capacity_end = m_begin + capacity;
end_ = begin_ + size;
capacity_end_ = begin_ + capacity;
uninitialized_copy_n(other.data(), size, m_begin);
uninitialized_copy_n(other.data(), size, begin_);
UPDATE_VECTOR_SIZE(this);
}
};

206
source/blender/blenlib/BLI_vector_set.hh
View File

@ -106,30 +106,30 @@ class VectorSet {
* Slots are either empty, occupied or removed. The number of occupied slots can be computed by
* subtracting the removed slots from the occupied-and-removed slots.
*/
uint32_t m_removed_slots;
uint32_t m_occupied_and_removed_slots;
uint32_t removed_slots_;
uint32_t occupied_and_removed_slots_;
/**
* The maximum number of slots that can be used (either occupied or removed) until the set has to
* grow. This is the total number of slots times the max load factor.
*/
uint32_t m_usable_slots;
uint32_t usable_slots_;
/**
* The number of slots minus one. This is a bit mask that can be used to turn any integer into a
* valid slot index efficiently.
*/
uint32_t m_slot_mask;
uint32_t slot_mask_;
/** This is called to hash incoming keys. */
Hash m_hash;
Hash hash_;
/** This is called to check equality of two keys. */
IsEqual m_is_equal;
IsEqual is_equal_;
/** The max load factor is 1/2 = 50% by default. */
#define LOAD_FACTOR 1, 2
LoadFactor m_max_load_factor = LoadFactor(LOAD_FACTOR);
LoadFactor max_load_factor_ = LoadFactor(LOAD_FACTOR);
using SlotArray = Array<Slot, LoadFactor::compute_total_slots(4, LOAD_FACTOR), Allocator>;
#undef LOAD_FACTOR
@ -137,19 +137,19 @@ class VectorSet {
* This is the array that contains the actual slots. There is always at least one empty slot and
* the size of the array is a power of two.
*/
SlotArray m_slots;
SlotArray slots_;
/**
* Pointer to an array that contains all keys. The keys are sorted by insertion order as long as
* no keys are removed. The first set->size() elements in this array are initialized. The
* capacity of the array is m_usable_slots.
* capacity of the array is usable_slots_.
*/
Key *m_keys;
Key *keys_;
/** Iterate over a slot index sequence for a given hash. */
#define VECTOR_SET_SLOT_PROBING_BEGIN(HASH, R_SLOT) \
SLOT_PROBING_BEGIN (ProbingStrategy, HASH, m_slot_mask, SLOT_INDEX) \
auto &R_SLOT = m_slots[SLOT_INDEX];
SLOT_PROBING_BEGIN (ProbingStrategy, HASH, slot_mask_, SLOT_INDEX) \
auto &R_SLOT = slots_[SLOT_INDEX];
#define VECTOR_SET_SLOT_PROBING_END() SLOT_PROBING_END()
public:
@ -159,12 +159,12 @@ class VectorSet {
* is performed on the first insertion.
*/
VectorSet()
: m_removed_slots(0),
m_occupied_and_removed_slots(0),
m_usable_slots(0),
m_slot_mask(0),
m_slots(1),
m_keys(nullptr)
: removed_slots_(0),
occupied_and_removed_slots_(0),
usable_slots_(0),
slot_mask_(0),
slots_(1),
keys_(nullptr)
{
}
@ -178,37 +178,37 @@ class VectorSet {
~VectorSet()
{
destruct_n(m_keys, this->size());
if (m_keys != nullptr) {
this->deallocate_keys_array(m_keys);
destruct_n(keys_, this->size());
if (keys_ != nullptr) {
this->deallocate_keys_array(keys_);
}
}
VectorSet(const VectorSet &other)
: m_removed_slots(other.m_removed_slots),
m_occupied_and_removed_slots(other.m_occupied_and_removed_slots),
m_usable_slots(other.m_usable_slots),
m_slot_mask(other.m_slot_mask),
m_slots(other.m_slots)
: removed_slots_(other.removed_slots_),
occupied_and_removed_slots_(other.occupied_and_removed_slots_),
usable_slots_(other.usable_slots_),
slot_mask_(other.slot_mask_),
slots_(other.slots_)
{
m_keys = this->allocate_keys_array(m_usable_slots);
uninitialized_copy_n(other.m_keys, other.size(), m_keys);
keys_ = this->allocate_keys_array(usable_slots_);
uninitialized_copy_n(other.keys_, other.size(), keys_);
}
VectorSet(VectorSet &&other) noexcept
: m_removed_slots(other.m_removed_slots),
m_occupied_and_removed_slots(other.m_occupied_and_removed_slots),
m_usable_slots(other.m_usable_slots),
m_slot_mask(other.m_slot_mask),
m_slots(std::move(other.m_slots)),
m_keys(other.m_keys)
: removed_slots_(other.removed_slots_),
occupied_and_removed_slots_(other.occupied_and_removed_slots_),
usable_slots_(other.usable_slots_),
slot_mask_(other.slot_mask_),
slots_(std::move(other.slots_)),
keys_(other.keys_)
{
other.m_removed_slots = 0;
other.m_occupied_and_removed_slots = 0;
other.m_usable_slots = 0;
other.m_slot_mask = 0;
other.m_slots = SlotArray(1);
other.m_keys = nullptr;
other.removed_slots_ = 0;
other.occupied_and_removed_slots_ = 0;
other.usable_slots_ = 0;
other.slot_mask_ = 0;
other.slots_ = SlotArray(1);
other.keys_ = nullptr;
}
VectorSet &operator=(const VectorSet &other)
@ -242,11 +242,11 @@ class VectorSet {
*/
void add_new(const Key &key)
{
this->add_new__impl(key, m_hash(key));
this->add_new__impl(key, hash_(key));
}
void add_new(Key &&key)
{
this->add_new__impl(std::move(key), m_hash(key));
this->add_new__impl(std::move(key), hash_(key));
}
/**
@ -269,7 +269,7 @@ class VectorSet {
*/
template<typename ForwardKey> bool add_as(ForwardKey &&key)
{
return this->add__impl(std::forward<ForwardKey>(key), m_hash(key));
return this->add__impl(std::forward<ForwardKey>(key), hash_(key));
}
/**
@ -301,7 +301,7 @@ class VectorSet {
*/
template<typename ForwardKey> bool contains_as(const ForwardKey &key) const
{
return this->contains__impl(key, m_hash(key));
return this->contains__impl(key, hash_(key));
}
/**
@ -320,7 +320,7 @@ class VectorSet {
*/
template<typename ForwardKey> bool remove_as(const ForwardKey &key)
{
return this->remove__impl(key, m_hash(key));
return this->remove__impl(key, hash_(key));
}
/**
@ -338,7 +338,7 @@ class VectorSet {
*/
template<typename ForwardKey> void remove_contained_as(const ForwardKey &key)
{
this->remove_contained__impl(key, m_hash(key));
this->remove_contained__impl(key, hash_(key));
}
/**
@ -364,7 +364,7 @@ class VectorSet {
*/
template<typename ForwardKey> uint32_t index_of_as(const ForwardKey &key) const
{
return this->index_of__impl(key, m_hash(key));
return this->index_of__impl(key, hash_(key));
}
/**
@ -381,7 +381,7 @@ class VectorSet {
*/
template<typename ForwardKey> int32_t index_of_try_as(const ForwardKey &key) const
{
return this->index_of_try__impl(key, m_hash(key));
return this->index_of_try__impl(key, hash_(key));
}
/**
@ -389,17 +389,17 @@ class VectorSet {
*/
const Key *data() const
{
return m_keys;
return keys_;
}
const Key *begin() const
{
return m_keys;
return keys_;
}
const Key *end() const
{
return m_keys + this->size();
return keys_ + this->size();
}
/**
@ -408,12 +408,12 @@ class VectorSet {
const Key &operator[](uint32_t index) const
{
BLI_assert(index <= this->size());
return m_keys[index];
return keys_[index];
}
operator Span<Key>() const
{
return Span<Key>(m_keys, this->size());
return Span<Key>(keys_, this->size());
}
/**
@ -441,7 +441,7 @@ class VectorSet {
*/
uint32_t size() const
{
return m_occupied_and_removed_slots - m_removed_slots;
return occupied_and_removed_slots_ - removed_slots_;
}
/**
@ -449,7 +449,7 @@ class VectorSet {
*/
bool is_empty() const
{
return m_occupied_and_removed_slots == m_removed_slots;
return occupied_and_removed_slots_ == removed_slots_;
}
/**
@ -457,7 +457,7 @@ class VectorSet {
*/
uint32_t capacity() const
{
return m_slots.size();
return slots_.size();
}
/**
@ -465,7 +465,7 @@ class VectorSet {
*/
uint32_t removed_amount() const
{
return m_removed_slots;
return removed_slots_;
}
/**
@ -482,7 +482,7 @@ class VectorSet {
*/
uint32_t size_in_bytes() const
{
return (uint32_t)(sizeof(Slot) * m_slots.size() + sizeof(Key) * m_usable_slots);
return (uint32_t)(sizeof(Slot) * slots_.size() + sizeof(Key) * usable_slots_);
}
/**
@ -490,7 +490,7 @@ class VectorSet {
*/
void reserve(uint32_t n)
{
if (m_usable_slots < n) {
if (usable_slots_ < n) {
this->realloc_and_reinsert(n);
}
}
@ -501,57 +501,57 @@ class VectorSet {
*/
uint32_t count_collisions(const Key &key) const
{
return this->count_collisions__impl(key, m_hash(key));
return this->count_collisions__impl(key, hash_(key));
}
private:
BLI_NOINLINE void realloc_and_reinsert(uint32_t min_usable_slots)
{
uint32_t total_slots, usable_slots;
m_max_load_factor.compute_total_and_usable_slots(
max_load_factor_.compute_total_and_usable_slots(
SlotArray::inline_buffer_capacity(), min_usable_slots, &total_slots, &usable_slots);
uint32_t new_slot_mask = total_slots - 1;
/* Optimize the case when the set was empty beforehand. We can avoid some copies here. */
if (this->size() == 0) {
m_slots.~Array();
new (&m_slots) SlotArray(total_slots);
m_removed_slots = 0;
m_occupied_and_removed_slots = 0;
m_usable_slots = usable_slots;
m_slot_mask = new_slot_mask;
m_keys = this->allocate_keys_array(usable_slots);
slots_.~Array();
new (&slots_) SlotArray(total_slots);
removed_slots_ = 0;
occupied_and_removed_slots_ = 0;
usable_slots_ = usable_slots;
slot_mask_ = new_slot_mask;
keys_ = this->allocate_keys_array(usable_slots);
return;
}
SlotArray new_slots(total_slots);
for (Slot &slot : m_slots) {
for (Slot &slot : slots_) {
if (slot.is_occupied()) {
this->add_after_grow_and_destruct_old(slot, new_slots, new_slot_mask);
}
}
Key *new_keys = this->allocate_keys_array(usable_slots);
uninitialized_relocate_n(m_keys, this->size(), new_keys);
this->deallocate_keys_array(m_keys);
uninitialized_relocate_n(keys_, this->size(), new_keys);
this->deallocate_keys_array(keys_);
/* All occupied slots have been destructed already and empty/removed slots are assumed to be
* trivially destructible. */
m_slots.clear_without_destruct();
m_slots = std::move(new_slots);
m_keys = new_keys;
m_occupied_and_removed_slots -= m_removed_slots;
m_usable_slots = usable_slots;
m_removed_slots = 0;
m_slot_mask = new_slot_mask;
slots_.clear_without_destruct();
slots_ = std::move(new_slots);
keys_ = new_keys;
occupied_and_removed_slots_ -= removed_slots_;
usable_slots_ = usable_slots;
removed_slots_ = 0;
slot_mask_ = new_slot_mask;
}
void add_after_grow_and_destruct_old(Slot &old_slot,
SlotArray &new_slots,
uint32_t new_slot_mask)
{
const Key &key = m_keys[old_slot.index()];
const Key &key = keys_[old_slot.index()];
uint32_t hash = old_slot.get_hash(key, Hash());
SLOT_PROBING_BEGIN (ProbingStrategy, hash, new_slot_mask, slot_index) {
@ -570,7 +570,7 @@ class VectorSet {
if (slot.is_empty()) {
return false;
}
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
return true;
}
}
@ -586,9 +586,9 @@ class VectorSet {
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
uint32_t index = this->size();
new (m_keys + index) Key(std::forward<ForwardKey>(key));
new (keys_ + index) Key(std::forward<ForwardKey>(key));
slot.occupy(index, hash);
m_occupied_and_removed_slots++;
occupied_and_removed_slots_++;
return;
}
}
@ -602,12 +602,12 @@ class VectorSet {
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.is_empty()) {
uint32_t index = this->size();
new (m_keys + index) Key(std::forward<ForwardKey>(key));
m_occupied_and_removed_slots++;
new (keys_ + index) Key(std::forward<ForwardKey>(key));
occupied_and_removed_slots_++;
slot.occupy(index, hash);
return true;
}
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
return false;
}
}
@ -619,7 +619,7 @@ class VectorSet {
BLI_assert(this->contains_as(key));
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
return slot.index();
}
}
@ -630,7 +630,7 @@ class VectorSet {
int32_t index_of_try__impl(const ForwardKey &key, uint32_t hash) const
{
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
return (int32_t)slot.index();
}
if (slot.is_empty()) {
@ -645,11 +645,11 @@ class VectorSet {
BLI_assert(this->size() > 0);
uint32_t index_to_pop = this->size() - 1;
Key key = std::move(m_keys[index_to_pop]);
m_keys[index_to_pop].~Key();
uint32_t hash = m_hash(key);
Key key = std::move(keys_[index_to_pop]);
keys_[index_to_pop].~Key();
uint32_t hash = hash_(key);
m_removed_slots++;
removed_slots_++;
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.has_index(index_to_pop)) {
@ -663,7 +663,7 @@ class VectorSet {
template<typename ForwardKey> bool remove__impl(const ForwardKey &key, uint32_t hash)
{
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
this->remove_key_internal(slot);
return true;
}
@ -679,7 +679,7 @@ class VectorSet {
BLI_assert(this->contains_as(key));
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
this->remove_key_internal(slot);
return;
}
@ -694,19 +694,19 @@ class VectorSet {
uint32_t last_element_index = size - 1;
if (index_to_remove < last_element_index) {
m_keys[index_to_remove] = std::move(m_keys[last_element_index]);
this->update_slot_index(m_keys[index_to_remove], last_element_index, index_to_remove);
keys_[index_to_remove] = std::move(keys_[last_element_index]);
this->update_slot_index(keys_[index_to_remove], last_element_index, index_to_remove);
}
m_keys[last_element_index].~Key();
keys_[last_element_index].~Key();
slot.remove();
m_removed_slots++;
removed_slots_++;
return;
}
void update_slot_index(const Key &key, uint32_t old_index, uint32_t new_index)
{
uint32_t hash = m_hash(key);
uint32_t hash = hash_(key);
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.has_index(old_index)) {
slot.update_index(new_index);
@ -722,7 +722,7 @@ class VectorSet {
uint32_t collisions = 0;
VECTOR_SET_SLOT_PROBING_BEGIN (hash, slot) {
if (slot.contains(key, m_is_equal, hash, m_keys)) {
if (slot.contains(key, is_equal_, hash, keys_)) {
return collisions;
}
if (slot.is_empty()) {
@ -735,20 +735,20 @@ class VectorSet {
void ensure_can_add()
{
if (m_occupied_and_removed_slots >= m_usable_slots) {
if (occupied_and_removed_slots_ >= usable_slots_) {
this->realloc_and_reinsert(this->size() + 1);
BLI_assert(m_occupied_and_removed_slots < m_usable_slots);
BLI_assert(occupied_and_removed_slots_ < usable_slots_);
}
}
Key *allocate_keys_array(uint32_t size)
{
return (Key *)m_slots.allocator().allocate((uint32_t)sizeof(Key) * size, alignof(Key), AT);
return (Key *)slots_.allocator().allocate((uint32_t)sizeof(Key) * size, alignof(Key), AT);
}
void deallocate_keys_array(Key *keys)
{
m_slots.allocator().deallocate(keys);
slots_.allocator().deallocate(keys);
}
};

22
source/blender/blenlib/BLI_vector_set_slots.hh
View File

@ -53,7 +53,7 @@ template<typename Key> class SimpleVectorSetSlot {
/**
* After the default constructor has run, the slot has to be in the empty state.
*/
int32_t m_state = s_is_empty;
int32_t state_ = s_is_empty;
public:
/**
@ -61,7 +61,7 @@ template<typename Key> class SimpleVectorSetSlot {
*/
bool is_occupied() const
{
return m_state >= 0;
return state_ >= 0;
}
/**
@ -69,7 +69,7 @@ template<typename Key> class SimpleVectorSetSlot {
*/
bool is_empty() const
{
return m_state == s_is_empty;
return state_ == s_is_empty;
}
/**
@ -78,7 +78,7 @@ template<typename Key> class SimpleVectorSetSlot {
uint32_t index() const
{
BLI_assert(this->is_occupied());
return (uint32_t)m_state;
return (uint32_t)state_;
}
/**
@ -91,8 +91,8 @@ template<typename Key> class SimpleVectorSetSlot {
uint32_t UNUSED(hash),
const Key *keys) const
{
if (m_state >= 0) {
return is_equal(key, keys[m_state]);
if (state_ >= 0) {
return is_equal(key, keys[state_]);
}
return false;
}
@ -106,7 +106,7 @@ template<typename Key> class SimpleVectorSetSlot {
{
BLI_assert(!this->is_occupied());
BLI_assert(other.is_occupied());
m_state = other.m_state;
state_ = other.state_;
}
/**
@ -116,7 +116,7 @@ template<typename Key> class SimpleVectorSetSlot {
void occupy(uint32_t index, uint32_t UNUSED(hash))
{
BLI_assert(!this->is_occupied());
m_state = (int32_t)index;
state_ = (int32_t)index;
}
/**
@ -126,7 +126,7 @@ template<typename Key> class SimpleVectorSetSlot {
void update_index(uint32_t index)
{
BLI_assert(this->is_occupied());
m_state = (int32_t)index;
state_ = (int32_t)index;
}
/**
@ -135,7 +135,7 @@ template<typename Key> class SimpleVectorSetSlot {
void remove()
{
BLI_assert(this->is_occupied());
m_state = s_is_removed;
state_ = s_is_removed;
}
/**
@ -143,7 +143,7 @@ template<typename Key> class SimpleVectorSetSlot {
*/
bool has_index(uint32_t index) const
{
return (uint32_t)m_state == index;
return (uint32_t)state_ == index;
}
/**

8
source/blender/blenlib/intern/BLI_index_range.cc
View File

@ -31,16 +31,16 @@ static std::mutex current_array_mutex;
Span<uint> IndexRange::as_span() const
{
uint min_required_size = m_start + m_size;
uint min_required_size = start_ + size_;
if (min_required_size <= current_array_size) {
return Span<uint>(current_array + m_start, m_size);
return Span<uint>(current_array + start_, size_);
}
std::lock_guard<std::mutex> lock(current_array_mutex);
if (min_required_size <= current_array_size) {
return Span<uint>(current_array + m_start, m_size);
return Span<uint>(current_array + start_, size_);
}
uint new_size = std::max<uint>(1000, power_of_2_max_u(min_required_size));
@ -54,7 +54,7 @@ Span<uint> IndexRange::as_span() const
std::atomic_thread_fence(std::memory_order_seq_cst);
current_array_size = new_size;
return Span<uint>(current_array + m_start, m_size);
return Span<uint>(current_array + start_, size_);
}
} // namespace blender

96
source/blender/blenlib/intern/dot_export.cc
View File

@ -27,8 +27,8 @@ namespace dot {
Node &Graph::new_node(StringRef label)
{
Node *node = new Node(*this);
m_nodes.append(std::unique_ptr<Node>(node));
m_top_level_nodes.add_new(node);
nodes_.append(std::unique_ptr<Node>(node));
top_level_nodes_.add_new(node);
node->set_attribute("label", label);
return *node;
}
@ -36,8 +36,8 @@ Node &Graph::new_node(StringRef label)
Cluster &Graph::new_cluster(StringRef label)
{
Cluster *cluster = new Cluster(*this);
m_clusters.append(std::unique_ptr<Cluster>(cluster));
m_top_level_clusters.add_new(cluster);
clusters_.append(std::unique_ptr<Cluster>(cluster));
top_level_clusters_.add_new(cluster);
cluster->set_attribute("label", label);
return *cluster;
}
@ -45,55 +45,55 @@ Cluster &Graph::new_cluster(StringRef label)
UndirectedEdge &UndirectedGraph::new_edge(NodePort a, NodePort b)
{
UndirectedEdge *edge = new UndirectedEdge(a, b);
m_edges.append(std::unique_ptr<UndirectedEdge>(edge));
edges_.append(std::unique_ptr<UndirectedEdge>(edge));
return *edge;
}
DirectedEdge &DirectedGraph::new_edge(NodePort from, NodePort to)
{
DirectedEdge *edge = new DirectedEdge(from, to);
m_edges.append(std::unique_ptr<DirectedEdge>(edge));
edges_.append(std::unique_ptr<DirectedEdge>(edge));
return *edge;
}
void Cluster::set_parent_cluster(Cluster *new_parent)
{
if (m_parent == new_parent) {
if (parent_ == new_parent) {
return;
}
else if (m_parent == nullptr) {
m_graph.m_top_level_clusters.remove(this);
new_parent->m_children.add_new(this);
else if (parent_ == nullptr) {
graph_.top_level_clusters_.remove(this);
new_parent->children_.add_new(this);
}
else if (new_parent == nullptr) {
m_parent->m_children.remove(this);
m_graph.m_top_level_clusters.add_new(this);
parent_->children_.remove(this);
graph_.top_level_clusters_.add_new(this);
}
else {
m_parent->m_children.remove(this);
new_parent->m_children.add_new(this);
parent_->children_.remove(this);
new_parent->children_.add_new(this);
}
m_parent = new_parent;
parent_ = new_parent;
}
void Node::set_parent_cluster(Cluster *cluster)
{
if (m_cluster == cluster) {
if (cluster_ == cluster) {
return;
}
else if (m_cluster == nullptr) {
m_graph.m_top_level_nodes.remove(this);
cluster->m_nodes.add_new(this);
else if (cluster_ == nullptr) {
graph_.top_level_nodes_.remove(this);
cluster->nodes_.add_new(this);
}
else if (cluster == nullptr) {
m_cluster->m_nodes.remove(this);
m_graph.m_top_level_nodes.add_new(this);
cluster_->nodes_.remove(this);
graph_.top_level_nodes_.add_new(this);
}
else {
m_cluster->m_nodes.remove(this);
cluster->m_nodes.add_new(this);
cluster_->nodes_.remove(this);
cluster->nodes_.add_new(this);
}
m_cluster = cluster;
cluster_ = cluster;
}
/* Utility methods
@ -101,7 +101,7 @@ void Node::set_parent_cluster(Cluster *cluster)
void Graph::set_random_cluster_bgcolors()
{
for (Cluster *cluster : m_top_level_clusters) {
for (Cluster *cluster : top_level_clusters_) {
cluster->set_random_cluster_bgcolors();
}
}
@ -113,7 +113,7 @@ void Cluster::set_random_cluster_bgcolors()
float value = 0.8f;
this->set_attribute("bgcolor", color_attr_from_hsv(hue, staturation, value));
for (Cluster *cluster : m_children) {
for (Cluster *cluster : children_) {
cluster->set_random_cluster_bgcolors();
}
}
@ -128,7 +128,7 @@ std::string DirectedGraph::to_dot_string() const
this->export__declare_nodes_and_clusters(ss);
ss << "\n";
for (const std::unique_ptr<DirectedEdge> &edge : m_edges) {
for (const std::unique_ptr<DirectedEdge> &edge : edges_) {
edge->export__as_edge_statement(ss);
ss << "\n";
}
@ -144,7 +144,7 @@ std::string UndirectedGraph::to_dot_string() const
this->export__declare_nodes_and_clusters(ss);
ss << "\n";
for (const std::unique_ptr<UndirectedEdge> &edge : m_edges) {
for (const std::unique_ptr<UndirectedEdge> &edge : edges_) {
edge->export__as_edge_statement(ss);
ss << "\n";
}
@ -156,14 +156,14 @@ std::string UndirectedGraph::to_dot_string() const
void Graph::export__declare_nodes_and_clusters(std::stringstream &ss) const
{
ss << "graph ";
m_attributes.export__as_bracket_list(ss);
attributes_.export__as_bracket_list(ss);
ss << "\n\n";
for (Node *node : m_top_level_nodes) {
for (Node *node : top_level_nodes_) {
node->export__as_declaration(ss);
}
for (Cluster *cluster : m_top_level_clusters) {
for (Cluster *cluster : top_level_clusters_) {
cluster->export__declare_nodes_and_clusters(ss);
}
}
@ -173,14 +173,14 @@ void Cluster::export__declare_nodes_and_clusters(std::stringstream &ss) const
ss << "subgraph cluster_" << (uintptr_t)this << " {\n";
ss << "graph ";
m_attributes.export__as_bracket_list(ss);
attributes_.export__as_bracket_list(ss);
ss << "\n\n";
for (Node *node : m_nodes) {
for (Node *node : nodes_) {
node->export__as_declaration(ss);
}
for (Cluster *cluster : m_children) {
for (Cluster *cluster : children_) {
cluster->export__declare_nodes_and_clusters(ss);
}
@ -189,26 +189,26 @@ void Cluster::export__declare_nodes_and_clusters(std::stringstream &ss) const
void DirectedEdge::export__as_edge_statement(std::stringstream &ss) const
{
m_a.to_dot_string(ss);
a_.to_dot_string(ss);
ss << " -> ";
m_b.to_dot_string(ss);
b_.to_dot_string(ss);
ss << " ";
m_attributes.export__as_bracket_list(ss);
attributes_.export__as_bracket_list(ss);
}
void UndirectedEdge::export__as_edge_statement(std::stringstream &ss) const
{
m_a.to_dot_string(ss);
a_.to_dot_string(ss);
ss << " -- ";
m_b.to_dot_string(ss);
b_.to_dot_string(ss);
ss << " ";
m_attributes.export__as_bracket_list(ss);
attributes_.export__as_bracket_list(ss);
}
void AttributeList::export__as_bracket_list(std::stringstream &ss) const
{
ss << "[";
m_attributes.foreach_item([&](StringRef key, StringRef value) {
attributes_.foreach_item([&](StringRef key, StringRef value) {
if (StringRef(value).startswith("<")) {
/* Don't draw the quotes, this is an html-like value. */
ss << key << "=" << value << ", ";
@ -229,15 +229,15 @@ void Node::export__as_declaration(std::stringstream &ss) const
{
this->export__as_id(ss);
ss << " ";
m_attributes.export__as_bracket_list(ss);
attributes_.export__as_bracket_list(ss);
ss << "\n";
}
void NodePort::to_dot_string(std::stringstream &ss) const
{
m_node->export__as_id(ss);
if (m_port_name.has_value()) {
ss << ":" << *m_port_name;
node_->export__as_id(ss);
if (port_name_.has_value()) {
ss << ":" << *port_name_;
}
}
@ -252,7 +252,7 @@ NodeWithSocketsRef::NodeWithSocketsRef(Node &node,
StringRef name,
Span<std::string> input_names,
Span<std::string> output_names)
: m_node(&node)
: node_(&node)
{
std::stringstream ss;
@ -297,8 +297,8 @@ NodeWithSocketsRef::NodeWithSocketsRef(Node &node,
ss << "</table>>";
m_node->set_attribute("label", ss.str());
m_node->set_shape(Attr_shape::Rectangle);
node_->set_attribute("label", ss.str());
node_->set_shape(Attr_shape::Rectangle);
}
} // namespace dot