HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Metadata.h
Go to the documentation of this file.
1 // Copyright Contributors to the OpenVDB Project
2 // SPDX-License-Identifier: MPL-2.0
3 
4 #ifndef OPENVDB_METADATA_HAS_BEEN_INCLUDED
5 #define OPENVDB_METADATA_HAS_BEEN_INCLUDED
6 
7 #include "version.h"
8 #include "Exceptions.h"
9 #include "Types.h"
10 #include "math/Math.h" // for math::isZero()
11 #include "util/Name.h"
12 #include <cstdint>
13 #include <iostream>
14 #include <string>
15 #include <vector>
16 
17 
18 namespace openvdb {
20 namespace OPENVDB_VERSION_NAME {
21 
22 /// @brief Base class for storing metadata information in a grid.
24 {
25 public:
28 
29  Metadata() {}
30  virtual ~Metadata() {}
31 
32  // Disallow copying of instances of this class.
33  Metadata(const Metadata&) = delete;
34  Metadata& operator=(const Metadata&) = delete;
35 
36  /// Return the type name of the metadata.
37  virtual Name typeName() const = 0;
38 
39  /// Return a copy of the metadata.
40  virtual Metadata::Ptr copy() const = 0;
41 
42  /// Copy the given metadata into this metadata.
43  virtual void copy(const Metadata& other) = 0;
44 
45  /// Return a textual representation of this metadata.
46  virtual std::string str() const = 0;
47 
48  /// Return the boolean representation of this metadata (empty strings
49  /// and zeroVals evaluate to false; most other values evaluate to true).
50  virtual bool asBool() const = 0;
51 
52  /// Return @c true if the given metadata is equivalent to this metadata.
53  bool operator==(const Metadata& other) const;
54  /// Return @c true if the given metadata is different from this metadata.
55  bool operator!=(const Metadata& other) const { return !(*this == other); }
56 
57  /// Return the size of this metadata in bytes.
58  virtual Index32 size() const = 0;
59 
60  /// Unserialize this metadata from a stream.
61  void read(std::istream&);
62  /// Serialize this metadata to a stream.
63  void write(std::ostream&) const;
64 
65  /// Create new metadata of the given type.
66  static Metadata::Ptr createMetadata(const Name& typeName);
67 
68  /// Return @c true if the given type is known by the metadata type registry.
69  static bool isRegisteredType(const Name& typeName);
70 
71  /// Clear out the metadata registry.
72  static void clearRegistry();
73 
74  /// Register the given metadata type along with a factory function.
75  static void registerType(const Name& typeName, Metadata::Ptr (*createMetadata)());
76  static void unregisterType(const Name& typeName);
77 
78 protected:
79  /// Read the size of the metadata from a stream.
80  static Index32 readSize(std::istream&);
81  /// Write the size of the metadata to a stream.
82  void writeSize(std::ostream&) const;
83 
84  /// Read the metadata from a stream.
85  virtual void readValue(std::istream&, Index32 numBytes) = 0;
86  /// Write the metadata to a stream.
87  virtual void writeValue(std::ostream&) const = 0;
88 };
89 
90 
91 /// @brief Subclass to hold raw data of an unregistered type
93 {
94 public:
95  using ByteVec = std::vector<uint8_t>;
96 
97  explicit UnknownMetadata(const Name& typ = "<unknown>"): mTypeName(typ) {}
98 
99  Name typeName() const override { return mTypeName; }
100  Metadata::Ptr copy() const override;
101  void copy(const Metadata&) override;
102  std::string str() const override { return (mBytes.empty() ? "" : "<binary data>"); }
103  bool asBool() const override { return !mBytes.empty(); }
104  Index32 size() const override { return static_cast<Index32>(mBytes.size()); }
105 
106  void setValue(const ByteVec& bytes) { mBytes = bytes; }
107  const ByteVec& value() const { return mBytes; }
108 
109 protected:
110  void readValue(std::istream&, Index32 numBytes) override;
111  void writeValue(std::ostream&) const override;
112 
113 private:
114  Name mTypeName;
115  ByteVec mBytes;
116 };
117 
118 
119 /// @brief Templated metadata class to hold specific types.
120 template<typename T>
121 class TypedMetadata: public Metadata
122 {
123 public:
126 
127  TypedMetadata();
128  TypedMetadata(const T& value);
129  TypedMetadata(const TypedMetadata<T>& other);
130  ~TypedMetadata() override;
131 
132  Name typeName() const override;
133  Metadata::Ptr copy() const override;
134  void copy(const Metadata& other) override;
135  std::string str() const override;
136  bool asBool() const override;
137  Index32 size() const override { return static_cast<Index32>(sizeof(T)); }
138 
139  /// Set this metadata's value.
140  void setValue(const T&);
141  /// Return this metadata's value.
142  T& value();
143  const T& value() const;
144 
145  // Static specialized function for the type name. This function must be
146  // template specialized for each type T.
147  static Name staticTypeName() { return typeNameAsString<T>(); }
148 
149  /// Create new metadata of this type.
150  static Metadata::Ptr createMetadata();
151 
152  static void registerType();
153  static void unregisterType();
154  static bool isRegisteredType();
155 
156 protected:
157  void readValue(std::istream&, Index32 numBytes) override;
158  void writeValue(std::ostream&) const override;
159 
160 private:
161  T mValue;
162 };
163 
164 /// Write a Metadata to an output stream
165 std::ostream& operator<<(std::ostream& ostr, const Metadata& metadata);
166 
167 
168 ////////////////////////////////////////
169 
170 
171 inline void
172 Metadata::writeSize(std::ostream& os) const
173 {
174  const Index32 n = this->size();
175  os.write(reinterpret_cast<const char*>(&n), sizeof(Index32));
176 }
177 
178 
179 inline Index32
180 Metadata::readSize(std::istream& is)
181 {
182  Index32 n = 0;
183  is.read(reinterpret_cast<char*>(&n), sizeof(Index32));
184  return n;
185 }
186 
187 
188 inline void
189 Metadata::read(std::istream& is)
190 {
191  const Index32 numBytes = this->readSize(is);
192  this->readValue(is, numBytes);
193 }
194 
195 
196 inline void
197 Metadata::write(std::ostream& os) const
198 {
199  this->writeSize(os);
200  this->writeValue(os);
201 }
202 
203 
204 ////////////////////////////////////////
205 
206 
207 template <typename T>
208 inline
210 {
211 }
212 
213 template <typename T>
214 inline
215 TypedMetadata<T>::TypedMetadata(const T &value) : mValue(value)
216 {
217 }
218 
219 template <typename T>
220 inline
222  Metadata(),
223  mValue(other.mValue)
224 {
225 }
226 
227 template <typename T>
228 inline
230 {
231 }
232 
233 template <typename T>
234 inline Name
236 {
238 }
239 
240 template <typename T>
241 inline void
243 {
244  mValue = val;
245 }
246 
247 template <typename T>
248 inline T&
250 {
251  return mValue;
252 }
253 
254 template <typename T>
255 inline const T&
257 {
258  return mValue;
259 }
260 
261 template <typename T>
262 inline Metadata::Ptr
264 {
265  Metadata::Ptr metadata(new TypedMetadata<T>());
266  metadata->copy(*this);
267  return metadata;
268 }
269 
270 template <typename T>
271 inline void
273 {
274  const TypedMetadata<T>* t = dynamic_cast<const TypedMetadata<T>*>(&other);
275  if (t == nullptr) OPENVDB_THROW(TypeError, "Incompatible type during copy");
276  mValue = t->mValue;
277 }
278 
279 
280 template<typename T>
281 inline void
282 TypedMetadata<T>::readValue(std::istream& is, Index32 /*numBytes*/)
283 {
284  //assert(this->size() == numBytes);
285  is.read(reinterpret_cast<char*>(&mValue), this->size());
286 }
287 
288 template<typename T>
289 inline void
290 TypedMetadata<T>::writeValue(std::ostream& os) const
291 {
292  os.write(reinterpret_cast<const char*>(&mValue), this->size());
293 }
294 
295 template <typename T>
296 inline std::string
298 {
299  std::ostringstream ostr;
300  ostr << mValue;
301  return ostr.str();
302 }
303 
304 template<typename T>
305 inline bool
307 {
308  return !math::isZero(mValue);
309 }
310 
311 template <typename T>
312 inline Metadata::Ptr
314 {
315  Metadata::Ptr ret(new TypedMetadata<T>());
316  return ret;
317 }
318 
319 template <typename T>
320 inline void
322 {
325 }
326 
327 template <typename T>
328 inline void
330 {
332 }
333 
334 template <typename T>
335 inline bool
337 {
339 }
340 
341 
342 template<>
343 inline std::string
345 {
346  return (mValue ? "true" : "false");
347 }
348 
349 
350 inline std::ostream&
351 operator<<(std::ostream& ostr, const Metadata& metadata)
352 {
353  ostr << metadata.str();
354  return ostr;
355 }
356 
357 
375 
376 
377 ////////////////////////////////////////
378 
379 
380 template<>
381 inline Index32
382 StringMetadata::size() const
383 {
384  return static_cast<Index32>(mValue.size());
385 }
386 
387 
388 template<>
389 inline std::string
390 StringMetadata::str() const
391 {
392  return mValue;
393 }
394 
395 
396 template<>
397 inline void
398 StringMetadata::readValue(std::istream& is, Index32 size)
399 {
400  mValue.resize(size, '\0');
401  is.read(&mValue[0], size);
402 }
403 
404 template<>
405 inline void
406 StringMetadata::writeValue(std::ostream& os) const
407 {
408  os.write(reinterpret_cast<const char*>(&mValue[0]), this->size());
409 }
410 
411 } // namespace OPENVDB_VERSION_NAME
412 } // namespace openvdb
413 
414 #endif // OPENVDB_METADATA_HAS_BEEN_INCLUDED
Name typeName() const override
Return the type name of the metadata.
Definition: Metadata.h:99
void read(std::istream &)
Unserialize this metadata from a stream.
Definition: Metadata.h:189
Definition: ImfName.h:54
std::ostream & operator<<(std::ostream &ostr, const Metadata &metadata)
Write a Metadata to an output stream.
Definition: Metadata.h:351
GLsizeiptr size
Definition: glew.h:1681
Metadata::Ptr copy() const override
Return a copy of the metadata.
Definition: Metadata.h:263
std::string str() const override
Return a textual representation of this metadata.
Definition: Metadata.h:102
T & value()
Return this metadata's value.
Definition: Metadata.h:249
Index32 size() const override
Return the size of this metadata in bytes.
Definition: Metadata.h:104
Name typeName() const override
Return the type name of the metadata.
Definition: Metadata.h:235
GLuint const GLfloat * val
Definition: glew.h:2794
UnknownMetadata(const Name &typ="<unknown>")
Definition: Metadata.h:97
virtual Index32 size() const =0
Return the size of this metadata in bytes.
virtual std::string str() const =0
Return a textual representation of this metadata.
static void unregisterType(const Name &typeName)
static Index32 readSize(std::istream &)
Read the size of the metadata from a stream.
Definition: Metadata.h:180
#define OPENVDB_USE_VERSION_NAMESPACE
Definition: version.h:166
bool operator!=(const Metadata &other) const
Return true if the given metadata is different from this metadata.
Definition: Metadata.h:55
SharedPtr< const Metadata > ConstPtr
Definition: Metadata.h:27
void read(T &in, bool &v)
Definition: ImfXdr.h:611
void write(std::ostream &) const
Serialize this metadata to a stream.
Definition: Metadata.h:197
std::string str() const override
Return a textual representation of this metadata.
Definition: Metadata.h:297
std::shared_ptr< T > SharedPtr
Definition: Types.h:91
static bool isRegisteredType(const Name &typeName)
Return true if the given type is known by the metadata type registry.
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
#define OPENVDB_API
Helper macros for defining library symbol visibility.
Definition: Platform.h:230
Subclass to hold raw data of an unregistered type.
Definition: Metadata.h:92
Templated metadata class to hold specific types.
Definition: Metadata.h:121
General-purpose arithmetic and comparison routines, most of which accept arbitrary value types (or at...
GLsizei n
Definition: glew.h:4040
void setValue(const ByteVec &bytes)
Definition: Metadata.h:106
void setValue(const T &)
Set this metadata's value.
Definition: Metadata.h:242
virtual void writeValue(std::ostream &) const =0
Write the metadata to a stream.
void writeValue(std::ostream &) const override
Write the metadata to a stream.
Definition: Metadata.h:290
static void registerType(const Name &typeName, Metadata::Ptr(*createMetadata)())
Register the given metadata type along with a factory function.
void readValue(std::istream &, Index32 numBytes) override
Read the metadata from a stream.
Definition: Metadata.h:282
GLsizei const GLchar *const * string
Definition: glew.h:1844
virtual void readValue(std::istream &, Index32 numBytes)=0
Read the metadata from a stream.
OIIO_API bool copy(string_view from, string_view to, std::string &err)
Base class for storing metadata information in a grid.
Definition: Metadata.h:23
Index32 size() const override
Return the size of this metadata in bytes.
Definition: Metadata.h:137
void write(T &out, bool v)
Definition: ImfXdr.h:332
#define OPENVDB_VERSION_NAME
The version namespace name for this library version.
Definition: version.h:112
GLsizei const GLfloat * value
Definition: glew.h:1849
GLdouble GLdouble t
Definition: glew.h:1398
static Metadata::Ptr createMetadata()
Create new metadata of this type.
Definition: Metadata.h:313
void writeSize(std::ostream &) const
Write the size of the metadata to a stream.
Definition: Metadata.h:172
bool isZero(const Type &x)
Return true if x is exactly equal to zero.
Definition: Math.h:301
#define OPENVDB_THROW(exception, message)
Definition: Exceptions.h:82