OpenVDB 9.0.0
AttributeArrayString.h
Go to the documentation of this file.
1// Copyright Contributors to the OpenVDB Project
2// SPDX-License-Identifier: MPL-2.0
3
4/// @file points/AttributeArrayString.h
5///
6/// @author Dan Bailey
7///
8/// @brief Attribute array storage for string data using Descriptor Metadata.
9
10#ifndef OPENVDB_POINTS_ATTRIBUTE_ARRAY_STRING_HAS_BEEN_INCLUDED
11#define OPENVDB_POINTS_ATTRIBUTE_ARRAY_STRING_HAS_BEEN_INCLUDED
12
13#include "AttributeArray.h"
14#include <memory>
15#include <deque>
16#include <unordered_map>
17
18
19namespace openvdb {
21namespace OPENVDB_VERSION_NAME {
22namespace points {
23
24
25////////////////////////////////////////
26
27
28namespace attribute_traits
29{
30 template <bool Truncate> struct StringTypeTrait { using Type = Index; };
31 template<> struct StringTypeTrait</*Truncate=*/true> { using Type = uint16_t; };
32}
33
34
35template <bool Truncate>
37{
39
40 template <typename T>
42
43 template<typename StorageType> static void decode(const StorageType&, ValueType&);
44 template<typename StorageType> static void encode(const ValueType&, StorageType&);
45 static const char* name() { return Truncate ? "str_trnc" : "str"; }
46};
47
48
50
51
52////////////////////////////////////////
53
54
55/// Class to compute a string->index map from all string:N metadata
57{
58public:
59 using UniquePtr = std::unique_ptr<StringMetaCache>;
60 using ValueMap = std::unordered_map<Name, Index>;
61
62 StringMetaCache() = default;
63 explicit StringMetaCache(const MetaMap& metadata);
64
65 /// Return @c true if no string elements in metadata
66 bool empty() const { return mCache.empty(); }
67 /// Returns the number of string elements in metadata
68 size_t size() const { return mCache.size(); }
69
70 /// Clears and re-populates the cache
71 void reset(const MetaMap& metadata);
72
73 /// Insert a new element in the cache
74 void insert(const Name& key, Index index);
75
76 /// Retrieve the value map (string -> index)
77 const ValueMap& map() const { return mCache; }
78
79private:
80 ValueMap mCache;
81}; // StringMetaCache
82
83
84////////////////////////////////////////
85
86
87/// Class to help with insertion of keyed string values into metadata
89{
90public:
91 using UniquePtr = std::unique_ptr<StringMetaInserter>;
92
93 explicit StringMetaInserter(MetaMap& metadata);
94
95 /// Returns @c true if key exists
96 bool hasKey(const Name& key) const;
97 /// Returns @c true if index exists
98 bool hasIndex(Index index) const;
99
100 /// @brief Insert the string into the metadata using the hint if non-zero
101 /// @param name the string to insert
102 /// @param hint requested index to use if non-zero and not already in use
103 /// @note the hint can be used to insert non-sequentially so as to avoid an
104 /// expensive re-indexing of string keys
105 /// @return the chosen index which will match hint if the hint was used
106 Index insert(const Name& name, Index hint = Index(0));
107
108 /// Reset the cache from the metadata
110
111private:
112 using IndexPairArray = std::deque<std::pair<Index, Index>>;
113
114 MetaMap& mMetadata;
115 IndexPairArray mIdBlocks;
116 StringMetaCache mCache;
117}; // StringMetaInserter
118
119
120////////////////////////////////////////
121
122
123template <bool Truncate>
124template<typename StorageType>
125inline void
126StringCodec<Truncate>::decode(const StorageType& data, ValueType& val)
127{
128 val = static_cast<ValueType>(data);
129}
130
131
132template <bool Truncate>
133template<typename StorageType>
134inline void
135StringCodec<Truncate>::encode(const ValueType& val, StorageType& data)
136{
137 data = static_cast<ValueType>(val);
138}
139
140
141////////////////////////////////////////
142
143
144inline bool isString(const AttributeArray& array)
145{
146 return array.isType<StringAttributeArray>();
147}
148
149
150////////////////////////////////////////
151
152
154{
155public:
156 using Ptr = std::shared_ptr<StringAttributeHandle>;//SharedPtr<StringAttributeHandle>;
157 using UniquePtr = std::unique_ptr<StringAttributeHandle>;
158
159 static Ptr create(const AttributeArray& array, const MetaMap& metadata, const bool preserveCompression = true);
160
162 const MetaMap& metadata,
163 const bool preserveCompression = true);
164
165 Index stride() const { return mHandle.stride(); }
166 Index size() const { return mHandle.size(); }
167
168 bool isUniform() const { return mHandle.isUniform(); }
169 bool hasConstantStride() const { return mHandle.hasConstantStride(); }
170
171 Name get(Index n, Index m = 0) const;
172 void get(Name& name, Index n, Index m = 0) const;
173
174 /// @brief Returns a reference to the array held in the Handle.
175 const AttributeArray& array() const;
176
177protected:
180}; // class StringAttributeHandle
181
182
183////////////////////////////////////////
184
185
187{
188public:
189 using Ptr = std::shared_ptr<StringAttributeWriteHandle>;//SharedPtr<StringAttributeWriteHandle>;
190 using UniquePtr = std::unique_ptr<StringAttributeWriteHandle>;
191
192 static Ptr create(AttributeArray& array, const MetaMap& metadata, const bool expand = true);
193
195 const MetaMap& metadata,
196 const bool expand = true);
197
198 /// @brief If this array is uniform, replace it with an array of length size().
199 /// @param fill if true, assign the uniform value to each element of the array.
200 void expand(bool fill = true);
201
202 /// @brief Set membership for the whole array and attempt to collapse
203 void collapse();
204 /// @brief Set membership for the whole array and attempt to collapse
205 /// @param name Name of the String
206 void collapse(const Name& name);
207
208 /// Compact the existing array to become uniform if all values are identical
209 bool compact();
210
211 /// @brief Fill the existing array with the given value.
212 /// @note Identical to collapse() except a non-uniform array will not become uniform.
213 void fill(const Name& name);
214
215 /// Set the value of the index to @a name
216 void set(Index n, const Name& name);
217 void set(Index n, Index m, const Name& name);
218
219 /// Reset the value cache from the metadata
221
222 /// @brief Returns a reference to the array held in the Write Handle.
224
225 /// @brief Returns whether or not the metadata cache contains a given value.
226 /// @param name Name of the String.
227 bool contains(const Name& name) const;
228
229private:
230 /// Retrieve the index of this string value from the cache
231 /// @note throws if name does not exist in cache
232 Index getIndex(const Name& name) const;
233
234 StringMetaCache mCache;
236}; // class StringAttributeWriteHandle
237
238
239////////////////////////////////////////
240
241
242} // namespace points
243} // namespace OPENVDB_VERSION_NAME
244} // namespace openvdb
245
246#endif // OPENVDB_POINTS_ATTRIBUTE_ARRAY_STRING_HAS_BEEN_INCLUDED
247
Attribute Array storage templated on type and compression codec.
#define OPENVDB_API
Definition: Platform.h:254
Container that maps names (strings) to values of arbitrary types.
Definition: MetaMap.h:20
Base class for storing attribute data.
Definition: AttributeArray.h:93
bool isType() const
Return true if this attribute is of the same type as the template parameter.
Definition: AttributeArray.h:214
Definition: AttributeArray.h:811
Write-able version of AttributeHandle.
Definition: AttributeArray.h:882
Definition: AttributeArrayString.h:154
AttributeHandle< Index, StringCodec< false > > mHandle
Definition: AttributeArrayString.h:178
Index size() const
Definition: AttributeArrayString.h:166
std::unique_ptr< StringAttributeHandle > UniquePtr
Definition: AttributeArrayString.h:157
Index stride() const
Definition: AttributeArrayString.h:165
Name get(Index n, Index m=0) const
std::shared_ptr< StringAttributeHandle > Ptr
Definition: AttributeArrayString.h:156
static Ptr create(const AttributeArray &array, const MetaMap &metadata, const bool preserveCompression=true)
const MetaMap & mMetadata
Definition: AttributeArrayString.h:179
StringAttributeHandle(const AttributeArray &array, const MetaMap &metadata, const bool preserveCompression=true)
const AttributeArray & array() const
Returns a reference to the array held in the Handle.
bool isUniform() const
Definition: AttributeArrayString.h:168
bool hasConstantStride() const
Definition: AttributeArrayString.h:169
void get(Name &name, Index n, Index m=0) const
Definition: AttributeArrayString.h:187
void fill(const Name &name)
Fill the existing array with the given value.
bool contains(const Name &name) const
Returns whether or not the metadata cache contains a given value.
bool compact()
Compact the existing array to become uniform if all values are identical.
void collapse()
Set membership for the whole array and attempt to collapse.
void resetCache()
Reset the value cache from the metadata.
void collapse(const Name &name)
Set membership for the whole array and attempt to collapse.
void expand(bool fill=true)
If this array is uniform, replace it with an array of length size().
AttributeArray & array()
Returns a reference to the array held in the Write Handle.
void set(Index n, Index m, const Name &name)
void set(Index n, const Name &name)
Set the value of the index to name.
static Ptr create(AttributeArray &array, const MetaMap &metadata, const bool expand=true)
StringAttributeWriteHandle(AttributeArray &array, const MetaMap &metadata, const bool expand=true)
Class to compute a string->index map from all string:N metadata.
Definition: AttributeArrayString.h:57
void insert(const Name &key, Index index)
Insert a new element in the cache.
std::unique_ptr< StringMetaCache > UniquePtr
Definition: AttributeArrayString.h:59
size_t size() const
Returns the number of string elements in metadata.
Definition: AttributeArrayString.h:68
bool empty() const
Return true if no string elements in metadata.
Definition: AttributeArrayString.h:66
StringMetaCache(const MetaMap &metadata)
std::unordered_map< Name, Index > ValueMap
Definition: AttributeArrayString.h:60
void reset(const MetaMap &metadata)
Clears and re-populates the cache.
const ValueMap & map() const
Retrieve the value map (string -> index)
Definition: AttributeArrayString.h:77
Class to help with insertion of keyed string values into metadata.
Definition: AttributeArrayString.h:89
bool hasIndex(Index index) const
Returns true if index exists.
void resetCache()
Reset the cache from the metadata.
Index insert(const Name &name, Index hint=Index(0))
Insert the string into the metadata using the hint if non-zero.
std::unique_ptr< StringMetaInserter > UniquePtr
Definition: AttributeArrayString.h:91
bool hasKey(const Name &key) const
Returns true if key exists.
Typed class for storing attribute data.
Definition: AttributeArray.h:533
Type Truncate(Type x, unsigned int digits)
Return x truncated to the given number of decimal digits.
Definition: Math.h:873
bool isString(const AttributeArray &array)
Definition: AttributeArrayString.h:144
std::string Name
Definition: Name.h:17
Index32 Index
Definition: Types.h:54
Definition: Exceptions.h:13
Definition: AttributeArrayString.h:41
typename attribute_traits::StringTypeTrait< Truncate >::Type Type
Definition: AttributeArrayString.h:41
Definition: AttributeArrayString.h:37
static const char * name()
Definition: AttributeArrayString.h:45
Index ValueType
Definition: AttributeArrayString.h:38
uint16_t Type
Definition: AttributeArrayString.h:31
Index Type
Definition: AttributeArrayString.h:30
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h.in:116
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h.in:202