OpenVDB  8.1.1
AttributeArrayString.h
Go to the documentation of this file.
1 // Copyright Contributors to the OpenVDB Project
2 // SPDX-License-Identifier: MPL-2.0
3 
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 
19 namespace openvdb {
21 namespace OPENVDB_VERSION_NAME {
22 namespace points {
23 
24 
26 
27 
28 namespace 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 
35 template <bool Truncate>
37 {
38  using ValueType = Index;
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 
53 
54 
57 {
58 public:
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 
66  bool empty() const { return mCache.empty(); }
68  size_t size() const { return mCache.size(); }
69 
71  void reset(const MetaMap& metadata);
72 
74  void insert(const Name& key, Index index);
75 
77  const ValueMap& map() const { return mCache; }
78 
79 private:
80  ValueMap mCache;
81 }; // StringMetaCache
82 
83 
85 
86 
89 {
90 public:
91  using UniquePtr = std::unique_ptr<StringMetaInserter>;
92 
93  explicit StringMetaInserter(MetaMap& metadata);
94 
96  bool hasKey(const Name& key) const;
98  bool hasIndex(Index index) const;
99 
106  Index insert(const Name& name, Index hint = Index(0));
107 
109  void resetCache();
110 
111 private:
112  using IndexPairArray = std::deque<std::pair<Index, Index>>;
113 
114  MetaMap& mMetadata;
115  IndexPairArray mIdBlocks;
116  StringMetaCache mCache;
117 }; // StringMetaInserter
118 
119 
121 
122 
123 template <bool Truncate>
124 template<typename StorageType>
125 inline void
126 StringCodec<Truncate>::decode(const StorageType& data, ValueType& val)
127 {
128  val = static_cast<ValueType>(data);
129 }
130 
131 
132 template <bool Truncate>
133 template<typename StorageType>
134 inline void
135 StringCodec<Truncate>::encode(const ValueType& val, StorageType& data)
136 {
137  data = static_cast<ValueType>(val);
138 }
139 
140 
142 
143 
144 inline bool isString(const AttributeArray& array)
145 {
146  return array.isType<StringAttributeArray>();
147 }
148 
149 
151 
152 
154 {
155 public:
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 
175  const AttributeArray& array() const;
176 
177 protected:
180 }; // class StringAttributeHandle
181 
182 
184 
185 
187 {
188 public:
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 
200  void expand(bool fill = true);
201 
203  void collapse();
206  void collapse(const Name& name);
207 
209  bool compact();
210 
213  void fill(const Name& name);
214 
216  void set(Index n, const Name& name);
217  void set(Index n, Index m, const Name& name);
218 
220  void resetCache();
221 
223  AttributeArray& array();
224 
227  bool contains(const Name& name) const;
228 
229 private:
232  Index getIndex(const Name& name) const;
233 
234  StringMetaCache mCache;
236 }; // class StringAttributeWriteHandle
237 
238 
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 
Write-able version of AttributeHandle.
Definition: AttributeArray.h:871
#define OPENVDB_API
Helper macros for defining library symbol visibility.
Definition: Platform.h:240
std::unordered_map< Name, Index > ValueMap
Definition: AttributeArrayString.h:60
bool isString(const AttributeArray &array)
Definition: AttributeArrayString.h:144
static const char * name()
Definition: AttributeArrayString.h:45
Attribute Array storage templated on type and compression codec.
Class to compute a string->index map from all string:N metadata.
Definition: AttributeArrayString.h:56
Definition: AttributeArray.h:800
Index stride() const
Definition: AttributeArrayString.h:165
std::string Name
Definition: Name.h:17
Definition: AttributeArrayString.h:41
Class to help with insertion of keyed string values into metadata.
Definition: AttributeArrayString.h:88
std::unique_ptr< StringMetaCache > UniquePtr
Definition: AttributeArrayString.h:59
Index ValueType
Definition: AttributeArrayString.h:38
size_t size() const
Returns the number of string elements in metadata.
Definition: AttributeArrayString.h:68
Type Truncate(Type x, unsigned int digits)
Return x truncated to the given number of decimal digits.
Definition: Math.h:873
Index Type
Definition: AttributeArrayString.h:30
Definition: AttributeArrayString.h:186
Index32 Index
Definition: openvdb/Types.h:50
Base class for storing attribute data.
Definition: AttributeArray.h:92
Definition: AttributeArrayString.h:36
const MetaMap & mMetadata
Definition: AttributeArrayString.h:179
const ValueMap & map() const
Retrieve the value map (string -> index)
Definition: AttributeArrayString.h:77
std::unique_ptr< StringMetaInserter > UniquePtr
Definition: AttributeArrayString.h:91
Definition: openvdb/Exceptions.h:13
uint16_t Type
Definition: AttributeArrayString.h:31
Typed class for storing attribute data.
Definition: AttributeArray.h:527
bool empty() const
Return true if no string elements in metadata.
Definition: AttributeArrayString.h:66
bool isUniform() const
Definition: AttributeArrayString.h:168
bool isType() const
Return true if this attribute is of the same type as the template parameter.
Definition: AttributeArray.h:214
bool hasConstantStride() const
Definition: AttributeArrayString.h:169
std::unique_ptr< StringAttributeHandle > UniquePtr
Definition: AttributeArrayString.h:157
Definition: AttributeArrayString.h:153
typename attribute_traits::StringTypeTrait< Truncate >::Type Type
Definition: AttributeArrayString.h:41
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h.in:116
AttributeHandle< Index, StringCodec< false > > mHandle
Definition: AttributeArrayString.h:178
Index size() const
Definition: AttributeArrayString.h:166
Container that maps names (strings) to values of arbitrary types.
Definition: MetaMap.h:19
std::shared_ptr< StringAttributeHandle > Ptr
Definition: AttributeArrayString.h:156
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h.in:178