[Bf-blender-cvs] [5fbf70b0d0c] master: Cleanup: use trailing underscore for non-public data members
Jacques Lucke
noreply at git.blender.org
Fri Jul 3 14:25:34 CEST 2020
Commit: 5fbf70b0d0c5a387d01bba4b4d536d166e16ac0e
Author: Jacques Lucke
Date: Fri Jul 3 14:20:42 2020 +0200
Branches: master
https://developer.blender.org/rB5fbf70b0d0c5a387d01bba4b4d536d166e16ac0e
Cleanup: use trailing underscore for non-public data members
===================================================================
M source/blender/functions/FN_array_spans.hh
M source/blender/functions/FN_attributes_ref.hh
M source/blender/functions/FN_cpp_type.hh
M source/blender/functions/FN_generic_vector_array.hh
M source/blender/functions/FN_multi_function.hh
M source/blender/functions/FN_multi_function_builder.hh
M source/blender/functions/FN_multi_function_data_type.hh
M source/blender/functions/FN_multi_function_network.hh
M source/blender/functions/FN_multi_function_network_evaluation.hh
M source/blender/functions/FN_multi_function_param_type.hh
M source/blender/functions/FN_multi_function_params.hh
M source/blender/functions/FN_multi_function_signature.hh
M source/blender/functions/FN_spans.hh
M source/blender/functions/intern/attributes_ref.cc
M source/blender/functions/intern/multi_function_network.cc
M source/blender/functions/intern/multi_function_network_evaluation.cc
===================================================================
diff --git a/source/blender/functions/FN_array_spans.hh b/source/blender/functions/FN_array_spans.hh
index acd3e921b50..139b949e55a 100644
--- a/source/blender/functions/FN_array_spans.hh
+++ b/source/blender/functions/FN_array_spans.hh
@@ -40,8 +40,8 @@ enum class VArraySpanCategory {
template<typename T> class VArraySpanBase {
protected:
- uint m_virtual_size;
- VArraySpanCategory m_category;
+ uint virtual_size_;
+ VArraySpanCategory category_;
union {
struct {
@@ -52,16 +52,16 @@ template<typename T> class VArraySpanBase {
const T *const *starts;
const uint *sizes;
} starts_and_sizes;
- } m_data;
+ } data_;
public:
bool is_single_array() const
{
- switch (m_category) {
+ switch (category_) {
case VArraySpanCategory::SingleArray:
return true;
case VArraySpanCategory::StartsAndSizes:
- return m_virtual_size == 1;
+ return virtual_size_ == 1;
}
BLI_assert(false);
return false;
@@ -69,12 +69,12 @@ template<typename T> class VArraySpanBase {
bool is_empty() const
{
- return this->m_virtual_size == 0;
+ return this->virtual_size_ == 0;
}
uint size() const
{
- return this->m_virtual_size;
+ return this->virtual_size_;
}
};
@@ -94,38 +94,38 @@ template<typename T> class VArraySpan : public VArraySpanBase<T> {
public:
VArraySpan()
{
- this->m_virtual_size = 0;
- this->m_category = VArraySpanCategory::StartsAndSizes;
- this->m_data.starts_and_sizes.starts = nullptr;
- this->m_data.starts_and_sizes.sizes = nullptr;
+ this->virtual_size_ = 0;
+ this->category_ = VArraySpanCategory::StartsAndSizes;
+ this->data_.starts_and_sizes.starts = nullptr;
+ this->data_.starts_and_sizes.sizes = nullptr;
}
VArraySpan(Span<T> span, uint virtual_size)
{
- this->m_virtual_size = virtual_size;
- this->m_category = VArraySpanCategory::SingleArray;
- this->m_data.single_array.start = span.data();
- this->m_data.single_array.size = span.size();
+ this->virtual_size_ = virtual_size;
+ this->category_ = VArraySpanCategory::SingleArray;
+ this->data_.single_array.start = span.data();
+ this->data_.single_array.size = span.size();
}
VArraySpan(Span<const T *> starts, Span<uint> sizes)
{
BLI_assert(starts.size() == sizes.size());
- this->m_virtual_size = starts.size();
- this->m_category = VArraySpanCategory::StartsAndSizes;
- this->m_data.starts_and_sizes.starts = starts.begin();
- this->m_data.starts_and_sizes.sizes = sizes.begin();
+ this->virtual_size_ = starts.size();
+ this->category_ = VArraySpanCategory::StartsAndSizes;
+ this->data_.starts_and_sizes.starts = starts.begin();
+ this->data_.starts_and_sizes.sizes = sizes.begin();
}
VSpan<T> operator[](uint index) const
{
- BLI_assert(index < this->m_virtual_size);
- switch (this->m_category) {
+ BLI_assert(index < this->virtual_size_);
+ switch (this->category_) {
case VArraySpanCategory::SingleArray:
- return VSpan<T>(Span<T>(this->m_data.single_array.start, this->m_data.single_array.size));
+ return VSpan<T>(Span<T>(this->data_.single_array.start, this->data_.single_array.size));
case VArraySpanCategory::StartsAndSizes:
- return VSpan<T>(Span<T>(this->m_data.starts_and_sizes.starts[index],
- this->m_data.starts_and_sizes.sizes[index]));
+ return VSpan<T>(Span<T>(this->data_.starts_and_sizes.starts[index],
+ this->data_.starts_and_sizes.sizes[index]));
}
BLI_assert(false);
return {};
@@ -138,68 +138,68 @@ template<typename T> class VArraySpan : public VArraySpanBase<T> {
*/
class GVArraySpan : public VArraySpanBase<void> {
private:
- const CPPType *m_type;
+ const CPPType *type_;
GVArraySpan() = default;
public:
GVArraySpan(const CPPType &type)
{
- this->m_type = &type;
- this->m_virtual_size = 0;
- this->m_category = VArraySpanCategory::StartsAndSizes;
- this->m_data.starts_and_sizes.starts = nullptr;
- this->m_data.starts_and_sizes.sizes = nullptr;
+ this->type_ = &type;
+ this->virtual_size_ = 0;
+ this->category_ = VArraySpanCategory::StartsAndSizes;
+ this->data_.starts_and_sizes.starts = nullptr;
+ this->data_.starts_and_sizes.sizes = nullptr;
}
GVArraySpan(GSpan array, uint virtual_size)
{
- this->m_type = &array.type();
- this->m_virtual_size = virtual_size;
- this->m_category = VArraySpanCategory::SingleArray;
- this->m_data.single_array.start = array.buffer();
- this->m_data.single_array.size = array.size();
+ this->type_ = &array.type();
+ this->virtual_size_ = virtual_size;
+ this->category_ = VArraySpanCategory::SingleArray;
+ this->data_.single_array.start = array.buffer();
+ this->data_.single_array.size = array.size();
}
GVArraySpan(const CPPType &type, Span<const void *> starts, Span<uint> sizes)
{
BLI_assert(starts.size() == sizes.size());
- this->m_type = &type;
- this->m_virtual_size = starts.size();
- this->m_category = VArraySpanCategory::StartsAndSizes;
- this->m_data.starts_and_sizes.starts = (void **)starts.begin();
- this->m_data.starts_and_sizes.sizes = sizes.begin();
+ this->type_ = &type;
+ this->virtual_size_ = starts.size();
+ this->category_ = VArraySpanCategory::StartsAndSizes;
+ this->data_.starts_and_sizes.starts = (void **)starts.begin();
+ this->data_.starts_and_sizes.sizes = sizes.begin();
}
template<typename T> GVArraySpan(VArraySpan<T> other)
{
- this->m_type = &CPPType::get<T>();
+ this->type_ = &CPPType::get<T>();
memcpy(this, &other, sizeof(VArraySpanBase<void>));
}
const CPPType &type() const
{
- return *this->m_type;
+ return *this->type_;
}
template<typename T> VArraySpan<T> typed() const
{
- BLI_assert(m_type->is<T>());
+ BLI_assert(type_->is<T>());
return VArraySpan<T>(*this);
}
GVSpan operator[](uint index) const
{
- BLI_assert(index < m_virtual_size);
- switch (m_category) {
+ BLI_assert(index < virtual_size_);
+ switch (category_) {
case VArraySpanCategory::SingleArray:
- return GVSpan(GSpan(*m_type, m_data.single_array.start, m_data.single_array.size));
+ return GVSpan(GSpan(*type_, data_.single_array.start, data_.single_array.size));
case VArraySpanCategory::StartsAndSizes:
return GVSpan(GSpan(
- *m_type, m_data.starts_and_sizes.starts[index], m_data.starts_and_sizes.sizes[index]));
+ *type_, data_.starts_and_sizes.starts[index], data_.starts_and_sizes.sizes[index]));
}
BLI_assert(false);
- return GVSpan(*m_type);
+ return GVSpan(*type_);
}
};
diff --git a/source/blender/functions/FN_attributes_ref.hh b/source/blender/functions/FN_attributes_ref.hh
index 383b26330bf..276c424ebf6 100644
--- a/source/blender/functions/FN_attributes_ref.hh
+++ b/source/blender/functions/FN_attributes_ref.hh
@@ -40,10 +40,10 @@ class AttributesInfo;
class AttributesInfoBuilder : NonCopyable, NonMovable {
private:
- LinearAllocator<> m_allocator;
- VectorSet<std::string> m_names;
- Vector<const CPPType *> m_types;
- Vector<void *> m_defaults;
+ LinearAllocator<> allocator_;
+ VectorSet<std::string> names_;
+ Vector<const CPPType *> types_;
+ Vector<void *> defaults_;
friend AttributesInfo;
@@ -65,11 +65,11 @@ class AttributesInfoBuilder : NonCopyable, NonMovable {
*/
class AttributesInfo : NonCopyable, NonMovable {
private:
- LinearAllocator<> m_allocator;
- Map<StringRefNull, uint> m_index_by_name;
- Vector<StringRefNull> m_name_by_index;
- Vector<const CPPType *> m_type_by_index;
- Vector<void *> m_defaults;
+ LinearAllocator<> allocator_;
+ Map<StringRefNull, uint> index_by_name_;
+ Vector<StringRefNull> name_by_index_;
+ Vector<const CPPType *> type_by_index_;
+ Vector<void *> defaults_;
public:
AttributesInfo() = default;
@@ -78,27 +78,27 @@ class AttributesInfo : NonCopyable, NonMovable {
uint size() const
{
- return m_name_by_index.size();
+ return name_by_index_.size();
}
IndexRange index_range() const
{
- return m_name_by_index.index_range();
+ return name_by_index_.index_range();
}
StringRefNull name_of(uint index) const
{
- return m_name_by_index[index];
+ return name_by_index_[index];
}
uint index_of(StringRef name) const
{
- return m_index_by_name.lookup_as(name);
+ return index_by_name_.lookup_as(name);
}
const void *default_of(uint index) const
{
- return m_defaults[index];
+ return defaults_[index];
}
const void *default_of(StringRef name) const
@@ -108,8 +108,8 @@ class AttributesInfo : NonCopyable, NonMovable {
template<typename T> const T &default_of(uint index) const
{
- BLI_assert(m_type_by_index[index]->is<T>());
- return *(T *)m_defaults[index];
+ BLI_assert(type_by_index_[index]->is<T>());
+ return *(T *)defaults_[index];
}
template<typename T> const T &default_of(StringRef name) const
@@ -119,7 +119,7 @@ class AttributesInfo : NonCopyable, NonMovable {
const CPPType &type_of(uint index) const
{
- return *m_type_by_index[index];
+ return *type_by_index_[index];
}
const CPPType &type_of(StringRef name) const
@@ -134,7 +134,7 @@ class AttributesInfo : NonCopyable, NonMovable {
int try_index_of(StringRef name) const
{
- return (int)m_index_by_name.lookup_default_as(name, -1);
+ return (int)index_by_name_.lookup_default_as(name, -1);
}
int try_index_of(StringRef name, const CPPType &type) const
@@ -158,9 +158,9 @@ class AttributesInfo : NonCopyable, NonMovable {
*/
class MutableAttributesRef {
private:
- const AttributesInfo *m_info;
- Span<void *> m_buffers;
- IndexRange m_range;
+ const AttributesInfo *info_;
+ Span<void *> buffers_;
+ IndexRange range_;
public:
MutableAttributesRef(const AttributesInfo &info, Span<void *> buffers, uint size)
@@ -169,46 +169,46 @@ class MutableAttributesRef {
}
MutableAttributesRef(const AttributesInfo &info, Span<void *> b
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list