HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GA_ATIBlob.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: GA_ATIBlob.h ( GA Library, C++)
7  *
8  * COMMENTS: Blob ATI (Attribute Type Implementation)
9  */
10 
11 #pragma once
12 
13 #ifndef __GA_ATIBlob__
14 #define __GA_ATIBlob__
15 
16 #include "GA_API.h"
17 #include "GA_Attribute.h"
18 #include "GA_BlobContainer.h"
19 #include "GA_BlobData.h"
20 #include "GA_PageArray.h"
21 #include "GA_Types.h"
22 
23 #include <UT/UT_StringHolder.h>
24 #include <UT/UT_VectorTypes.h>
25 
26 #include <SYS/SYS_Types.h>
27 
28 #include <stddef.h>
29 
30 
31 class GA_AIFBlob;
32 class GA_AIFCompare;
33 class GA_AIFCopyData;
34 class GA_AIFInterp;
35 class GA_AIFMerge;
36 class GA_AttributeType;
37 class GA_Defragment;
38 class GA_IndexMap;
39 class GA_LoadMap;
40 class GA_MergeMap;
41 class GA_SaveMap;
42 class GA_Range;
43 
44 class UT_JSONParser;
45 class UT_JSONWriter;
46 class UT_Options;
47 template <typename T> class UT_Array;
48 
49 
50 /// @brief Utility class to load blob data from a JSON stream
51 ///
52 /// Since blobs are opaque to the blob container, it's impossible to create
53 /// blobs when loading. If blobs need to be saved/loaded, a blob loader class
54 /// will have to be used to create blob data from the stream.
55 /// This class should load the data stored by the BlobData::jsonSave() method.
57 {
58 public:
59  virtual ~GA_BlobDataLoader() {}
60 
61  /// Load the data from the JSON parser and assign the blob to the handle
62  /// passed in. If there's an error loading the blob, then, return false.
63  virtual bool jsonLoad(UT_JSONParser &p,
64  const GA_LoadMap &load,
65  GA_BlobRef &handle) const = 0;
66 };
67 
68 /// @brief A simple ATI to store aribtrary "blobs" of data in an attribute
69 ///
70 /// The blob attribute type stores arbitrary blobs (GA_Blob) of data for each
71 /// element in the attribute array. The blobs are stored as reference counted
72 /// shared objects, meaning the blobs may be shared between multiple elements
73 /// of the array. Each blob is referenced by a unique integer handle.
74 ///
75 /// It's also possible to get a list of all the blobs stored by the attribute
76 ///
77 /// By default, the array is filled with NULL pointers.
78 ///
79 /// This class is very simple and only provides a minimal interface. Blob
80 /// attributes are not saved/loaded, and there is minimal access to the blobs.
81 ///
82 /// Users may sub-class from this ATI to create more complicated classes which
83 /// provide alternate interfaces.
84 ///
85 /// This attribute looks for options (GA_Attribute::getOptions())
86 /// - bool blob:stringset (default: true)@n
87 /// This option is queried when merging detail attributes. When true,
88 /// the @b unique blobs from both details will be merged into the resulting
89 /// detail. When false, the resulting detail will only have the blobs from
90 /// the first detail in the merge.
91 ///
93 {
94 public:
95  static void registerType();
97  static const UT_StringHolder &getTypeName()
98  { return theAttributeType->getTypeName(); }
100  static const GA_AttributeType &getType() { return *theAttributeType; }
101 
103  static bool isType(const GA_Attribute *attrib)
104  {
105  if (!attrib)
106  return false;
107  if (&attrib->getType() == theAttributeType)
108  return true;
109  if (dynamic_cast<const GA_ATIBlob *>(attrib))
110  return true;
111  return false;
112  }
114  static GA_ATIBlob *cast(GA_Attribute *attrib)
115  {
116  if (isType(attrib))
117  return static_cast<GA_ATIBlob *>(attrib);
118  return nullptr;
119  }
121  static const GA_ATIBlob *cast(const GA_Attribute *attrib)
122  {
123  if (isType(attrib))
124  return static_cast<const GA_ATIBlob *>(attrib);
125  return nullptr;
126  }
127 
128  static GA_Attribute *create(const GA_IndexMap &index_map,
129  GA_AttributeScope scope,
130  const UT_StringHolder &name,
131  int tuple_size,
132  const GA_AttributeOptions *attribute_options=NULL);
133  static GA_Attribute *create(const GA_IndexMap &index_map,
134  const UT_StringHolder &name,
135  int tuple_size)
136  {
137  return create(index_map, GA_SCOPE_PUBLIC, name,
138  tuple_size);
139  }
140 
142  const GA_IndexMap &index_map,
143  GA_AttributeScope scope,
144  const char *name,
145  int tuple_size);
146  ~GA_ATIBlob() override;
147 
148  /// Report approximate memory usage
149  int64 getMemoryUsage(bool inclusive) const override;
150 
151  void countMemory(UT_MemoryCounter &counter, bool inclusive) const override;
152 
153  /// @{
154  /// Interface for defragmentation
155  void defragment(const GA_Defragment &defrag) override;
156  /// @}
157 
159  GA_Offset offset, GA_Offset nelements) override;
160 
161  /// Get the tuple size
163  int getTupleSize() const
164  { return myHandles.getTupleSize(); }
165 
166  /// Return the entries in the blob container
167  int entries() const
168  { return myBlobs.entries(); }
169 
170  /// Return the maximum index of any blob in the container. This may be
171  /// more than the number of blobs in the container. If the maximum index
172  /// is less than 0, there are no blobs in the container.
174  { return myBlobs.getMaximumIndex(); }
175 
176  /// Return the capacity of the blob container
177  int capacity() const
178  { return myBlobs.capacity(); }
179 
180  /// Look up a blob handle by offset.
182  GA_BlobIndex getBlobIndex(GA_Offset offset, int tuple_index=0) const
183  {
184  if (tuple_index >= 0 && tuple_index < getTupleSize())
185  return GA_BlobIndex(myHandles.get(offset, tuple_index));
187  }
188 
189  /// Store a new blob_index at the given offset
190  bool setBlobIndex(GA_BlobIndex blob_index, GA_Offset offset,
191  int tuple_idx=0);
192 
193  /// Store a new blob_index at the given range of offsets
194  bool setBlobIndex(GA_BlobIndex blob_i,
195  const GA_Range &di,
196  int tuple_index = 0);
197 
198  /// Get the blob associated with a given offset into the array
199  /// @{
201  GA_BlobRef getBlob(GA_Offset offset, int tuple_idx = 0) const
202  {
203  return lookupBlob(getBlobIndex(offset, tuple_idx));
204  }
206  const GA_BlobData *getRawBlob(GA_Offset offset, int tuple_idx = 0) const
207  {
208  return lookupRawBlob(getBlobIndex(offset, tuple_idx));
209  }
210  /// @}
211 
212  /// Store a new blob at the given offset
213  bool setBlob(const GA_BlobRef &blob, GA_Offset offset,
214  int tuple_index = 0);
215 
216  /// Replace a blob in the blob container with a new blob value
217  bool replaceBlob(GA_BlobIndex handle,
218  const GA_BlobRef &blob);
219 
220 
221  /// Look up a blob given its handle
222  /// @{
225  { return myBlobs.getBlob(handle); }
226 
229  { return myBlobs.getRawBlob(handle); }
230  /// @}
231 
232  /// Lookup a blob given an ordered index
234  { return myBlobs.getOrderedBlob(idx); }
235 
236  /// This method will "compact" the attribute container, possibly changing
237  /// all the handles in the attribute data.
238  void compactStorage() override;
239 
240  /// Get a measure of the vacancy entropy of the storage container. This
242  { return myBlobs.getOccupancy(); }
243 
244  /// Adding blobs is thread-safe, so we're only subject to GA_PageArray
245  /// limitations.
247  { return WRITE_CONCURRENCE_PAGE; }
248 
249  const GA_AIFBlob *getAIFBlob() const override { return myAIFBlob; }
250  const GA_AIFMerge *getAIFMerge() const override { return myAIFMerge; }
251  const GA_AIFCompare *getAIFCompare() const override { return myAIFCompare;}
252  const GA_AIFCopyData *getAIFCopyData() const override{return myAIFCopyData;}
253  const GA_AIFInterp *getAIFInterp() const override { return myAIFInterp; }
254 
255  /// Save blobs to a JSON stream.
256  /// This method can be called by sub-classes to save blob data to a JSON
257  /// stream. Since the GA_ATIBlob class doesn't provide an GA_AIFJSON
258  /// interface, data is not saved/loaded by default.
259  ///
260  /// @param w The JSON writer
261  /// @param s The save map options
262  /// @param blobtoken The token used to identify the blob data
263  bool jsonSave(UT_JSONWriter &w,
264  const GA_SaveMap &s,
265  const char *blobtoken = "data") const;
266 
267  /// Load blobs from a JSON stream. This method can be called by
268  /// sub-classes to load their data from a JSON stream. The class must
269  /// provide a GA_BlobDataLoader class which is used to create and load new
270  /// blob data.
271  ///
272  /// @param p The JSON parser
273  /// @param blobloader A class to create and load blobs
274  /// @param load Load options
275  /// @param blobtoken The token used to identify the blob data
276  bool jsonLoad(UT_JSONParser &p,
277  const GA_BlobDataLoader &blobloader,
278  const GA_LoadMap &load,
279  const char *blobtoken = "data");
280 
281  /// Convenience function to extract all the blobs (and their handles)
282  /// The string handles are guaranteed to be in ascending order, but
283  /// may or may not be contiguous.
285  UT_IntArray &handles) const
286  {
287  return myBlobs.extractBlobs(blobs, handles);
288  }
290  UT_IntArray &handles, exint maxblobs) const
291  {
292  return myBlobs.extractBlobs(blobs, handles, maxblobs);
293  }
294 
295  /// Grow or shrink the array size
296  bool setArraySize(GA_Offset new_size) override;
297 
298  /// Try to compress data pages
299  void tryCompressAllPages(
300  GA_Offset start_offset = GA_Offset(0),
301  GA_Offset end_offset = GA_INVALID_OFFSET) override;
302  /// Harden data pages
303  void hardenAllPages(
304  GA_Offset start_offset = GA_Offset(0),
305  GA_Offset end_offset = GA_INVALID_OFFSET) override;
306 
307  /// Returns true iff that is an attribute whose content can be copied
308  /// from this without any type conversions. This is important to
309  /// avoid reallocation of an attribute if its storage type,
310  /// including tuple size, matches the source attribute exactly.
311  bool matchesStorage(const GA_Attribute *that) const override
312  {
313  if (!GA_Attribute::matchesStorage(that))
314  return false;
315  const GA_ATIBlob *thatn = UTverify_cast<const GA_ATIBlob *>(that);
316  if (getTupleSize() != thatn->getTupleSize())
317  return false;
318  return true;
319  }
320 
321  /// This replaces the entirety of this attribute's content and non-
322  /// storage metadata (except the name) with that of the src attribute.
323  /// matchesStorage(src) should already return true.
324  /// This is primarily for use by GA_AttributeSet::replace().
325  /// NOTE: The internal content sizes may not match exactly if the
326  /// attribute type may overallocate, but the sizes should be such
327  /// that any real data will fit in the destination, so be careful
328  /// and deal with the myTailInitialize flag appropriately if
329  /// any extra elements aren't equal to the default.
330  void replace(const GA_Attribute &src) override;
331 
332  /// Copy attribute values for a single element.
333  /// @{
334  bool copy(GA_Offset desti, GA_Offset srci) override final
335  {
336  copyData(desti, this, srci);
337  return true;
338  }
339  bool copy(GA_Offset desti,
340  const GA_Attribute &src, GA_Offset srci) override final
341  {
342  if (!GA_ATIBlob::isType(&src))
343  return false;
344  copyData(desti, UTverify_cast<const GA_ATIBlob *>(&src), srci);
345  return true;
346  }
347  bool copy(GA_Offset desti, const GA_ATIBlob &src, GA_Offset srci)
348  {
349  copyData(desti, &src, srci);
350  return true;
351  }
352  /// @}
353 
354  /// Copy attribute values for a range of elements.
355  /// @{
356  bool copy(const GA_Range &destrange,
357  const GA_Range &srcrange) override final
358  {
359  return copyData(destrange, this, srcrange);
360  }
361  bool copy(const GA_Range &destrange,
362  const GA_Attribute &src, const GA_Range &srcrange) override final
363  {
364  if (!GA_ATIBlob::isType(&src))
365  return false;
366  return copyData(destrange, UTverify_cast<const GA_ATIBlob*>(&src), srcrange);
367  }
368  bool copy(const GA_Range &destrange, const GA_ATIBlob &src, const GA_Range &srcrange)
369  {
370  return copyData(destrange, &src, srcrange);
371  }
372  /// @}
373 
374  /// Assign all elements of a range from a single attribute value.
375  /// @{
376  bool fill(const GA_Range &destrange, GA_Offset srci) override final
377  {
378  fillData(destrange, this, srci);
379  return true;
380  }
381  bool fill(const GA_Range &destrange,
382  const GA_Attribute &src, GA_Offset srci) override final
383  {
384  if (!GA_ATIBlob::isType(&src))
385  return false;
386  fillData(destrange, UTverify_cast<const GA_ATIBlob *>(&src), srci);
387  return true;
388  }
389  bool fill(const GA_Range &destrange, const GA_ATIBlob &src, GA_Offset srci)
390  {
391  fillData(destrange, &src, srci);
392  return true;
393  }
394  /// @}
395 
396  /// Validates the internal structure for debugging purposes.
397  bool validate() const;
398 
400 
401 protected: // Methods
402  /// Grow or shrink the tuple size
403  virtual bool setTupleSize(int size);
404 
405  /// Blob attributes need each element to properly destruct for accurate
406  /// reference counting.
407  bool needDestruction() const override;
408 
409  /// Callback method to destruct an offset.
410  void destructElement(GA_Offset offset) override;
411 
412  /// Create a new ATIBlob attribute. Sub-classes must implement this.
413  GA_Attribute *doClone(const GA_IndexMap &index_map,
414  const UT_StringHolder &name) const override;
415 
416  /// @{ GA_AIFMerge
417  /// Base class implementation of GA_AIFMerge::destroyDestination()
418  void mergeDestroyDestination(const GA_MergeMap &map,
419  GA_Attribute *dattrib) const;
420  /// Base class implementation of GA_AIFMerge::addDestination()
421  GA_Attribute *mergeAddDestination(const GA_MergeMap &map,
422  GA_Attribute *dattrib) const;
423  /// Base class implementation of GA_AIFMerge::growArray()
424  void mergeGrowArray(const GA_MergeMap &map, const GA_ATIBlob &s);
425 
426  /// Base class implementation of GA_AIFMerge::copyArray()
427  bool mergeAppendData(const GA_MergeMap &map,
428  const GA_Attribute *sattrib);
429  /// @}
430 
431  /// @{
432  /// Methods to implement copying of data for AIFCopyData
433  bool copyData(GA_Offset di,
434  const GA_ATIBlob *s,
435  GA_Offset si);
436  bool copyData(const GA_Range &di,
437  const GA_ATIBlob *s,
438  const GA_Range &si);
439  bool fillData(const GA_Range &di,
440  const GA_ATIBlob *s,
441  GA_Offset si);
442  /// @}
443 
444  /// @{
445  /// The addBlobBuffer()/delBlobBuffer() methods are added solely for the
446  /// corresponding methods in GA_AIFBlob.
447  GA_BlobIndex addBlobReference(const GA_BlobRef &blob);
448  void delBlobReference(GA_BlobIndex handle);
449  /// @}
450 
451  /// @{
452  /// Interface used by AIFCompare. By default, this will use the blob key
453  /// comparison to determine equality.
454  virtual bool isEqual(GA_Offset offset,
455  const GA_ATIBlob &b, GA_Offset b_offset) const;
456  virtual bool isEqual(const GA_Range & range,
457  const GA_ATIBlob &b, const GA_Range &b_range) const;
458  /// @}
459 
460 protected: // Data
461  /// Array of handles. The default value is -1.
462  /// This is protected for convenience to sub-classes.
464 
465  /// Blob references. This is protected for convenience to sub-classes.
467 
468 private:
469  /// Load up an array of blob
470  bool jsonLoadBlobs(UT_JSONParser &p,
471  const GA_LoadMap &load,
472  UT_Array<GA_BlobRef> &blobs,
473  const GA_BlobDataLoader &blobloader);
474 #if 0
475  /// Add references for the indices referenced by the elements in the
476  /// range optimized for the native format of myHandles.
477  template <typename T>
478  void addReferencesNativeImpl(const GA_Range &range);
479 #endif
480 
481  /// AIF Merge interface
482  static GA_AIFBlob *myAIFBlob;
483  static GA_AIFMerge *myAIFMerge;
484  static GA_AIFCopyData *myAIFCopyData;
485  static GA_AIFCompare *myAIFCompare;
486  static GA_AIFInterp *myAIFInterp;
487 
488  static const GA_AttributeType *theAttributeType;
489 
490  /// @cond INTERNAL_DOX
491  friend class ga_BlobBlob;
492  friend class ga_BlobMerge;
493  friend class ga_BlobCopyData;
494  friend class ga_BlobCompare;
495  /// @endcond
496 };
497 
498 #endif
fpreal getStorageOccupancy()
Get a measure of the vacancy entropy of the storage container. This.
Definition: GA_ATIBlob.h:241
A class to manage an ordered array which has fixed offset handles.
Definition: GA_IndexMap.h:63
HandleArrayType myHandles
Definition: GA_ATIBlob.h:463
bool copy(const GA_Range &destrange, const GA_Range &srcrange) overridefinal
Definition: GA_ATIBlob.h:356
GLboolean GLboolean GLboolean b
Definition: glcorearb.h:1221
Definition of a geometry attribute.
Definition: GA_Attribute.h:196
GLuint counter
Definition: glew.h:2745
Used to pass options and map offset values during saving.
Definition: GA_SaveMap.h:48
int getTupleSize() const
Size of the AIFTuple, if it exists. If it doesn't, 1.
bool fill(const GA_Range &destrange, const GA_ATIBlob &src, GA_Offset srci)
Definition: GA_ATIBlob.h:389
SYS_FORCE_INLINE GA_BlobIndex getBlobIndex(GA_Offset offset, int tuple_index=0) const
Look up a blob handle by offset.
Definition: GA_ATIBlob.h:182
The merge map keeps track of information when merging details.
Definition: GA_MergeMap.h:53
int64 exint
Definition: SYS_Types.h:125
virtual void reconstructElementBlock(GA_Offset offset, GA_Offset nelements)=0
bool matchesStorage(const GA_Attribute *that) const override
Definition: GA_ATIBlob.h:311
bool fill(const GA_Range &destrange, GA_Offset srci) overridefinal
Definition: GA_ATIBlob.h:376
JSON reader class which handles parsing of JSON or bJSON files.
Definition: UT_JSONParser.h:88
virtual bool setArraySize(GA_Offset size)=0
A simple ATI to store aribtrary "blobs" of data in an attribute.
Definition: GA_ATIBlob.h:92
#define GA_API
Definition: GA_API.h:14
Class which writes ASCII or binary JSON streams.
Definition: UT_JSONWriter.h:35
SYS_FORCE_INLINE TO_T UTverify_cast(FROM_T from)
Definition: UT_Assert.h:244
GLuint const GLchar * name
Definition: glcorearb.h:785
virtual void countMemory(UT_MemoryCounter &counter, bool inclusive) const =0
Standard user attribute level.
Definition: GA_Types.h:147
const GA_AIFCompare * getAIFCompare() const override
Return the attribute's comparison interface or NULL.
Definition: GA_ATIBlob.h:251
virtual int64 getMemoryUsage(bool inclusive) const =0
virtual bool matchesStorage(const GA_Attribute *that) const
Definition: GA_Attribute.h:744
GLenum src
Definition: glcorearb.h:1792
virtual void tryCompressAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
SYS_FORCE_INLINE GA_BlobRef getBlob(GA_Offset offset, int tuple_idx=0) const
Definition: GA_ATIBlob.h:201
#define GA_INVALID_OFFSET
Definition: GA_Types.h:677
A range of elements in an index-map.
Definition: GA_Range.h:42
static SYS_FORCE_INLINE const GA_ATIBlob * cast(const GA_Attribute *attrib)
Definition: GA_ATIBlob.h:121
GLsizeiptr size
Definition: glcorearb.h:663
GLubyte GLubyte GLubyte GLubyte w
Definition: glcorearb.h:856
GA_Size GA_Offset
Definition: GA_Types.h:640
static GA_Attribute * create(const GA_IndexMap &index_map, const UT_StringHolder &name, int tuple_size)
Definition: GA_ATIBlob.h:133
GA_AttributeScope
Definition: GA_Types.h:141
WriteConcurrence getSupportedWriteConcurrence() const override
Definition: GA_ATIBlob.h:246
virtual bool needDestruction() const
Methods which can be overridden from GA_Attribute.
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
SYS_FORCE_INLINE int getTupleSize() const
Get the tuple size.
Definition: GA_ATIBlob.h:163
Attribute Interface for accessing generic blob data.
Definition: GA_AIFBlob.h:39
int entries() const
Return the entries in the blob container.
Definition: GA_ATIBlob.h:167
Utility class to load blob data from a JSON stream.
Definition: GA_ATIBlob.h:56
virtual void replace(const GA_Attribute &src)=0
Attribute Interface for merging attribute data between details.
Definition: GA_AIFMerge.h:56
bool copy(GA_Offset desti, const GA_Attribute &src, GA_Offset srci) overridefinal
Definition: GA_ATIBlob.h:339
UT_IndexedHashMapItemId GA_BlobIndex
const GA_AIFCopyData * getAIFCopyData() const override
Return the attribute's copy interface or NULL.
Definition: GA_ATIBlob.h:252
SYS_FORCE_INLINE const GA_BlobData * getRawBlob(GA_Offset offset, int tuple_idx=0) const
Definition: GA_ATIBlob.h:206
SYS_FORCE_INLINE const GA_BlobData * lookupRawBlob(GA_BlobIndex handle) const
Definition: GA_ATIBlob.h:228
#define SYS_FORCE_INLINE
Definition: SYS_Inline.h:45
static SYS_FORCE_INLINE GA_ATIBlob * cast(GA_Attribute *attrib)
Definition: GA_ATIBlob.h:114
long long int64
Definition: SYS_Types.h:116
#define GA_INVALID_BLOB_INDEX
Attribute Interface class to perform comparisons on attributes.
Definition: GA_AIFCompare.h:27
GLfloat GLfloat p
Definition: glew.h:16656
Options during loading.
Definition: GA_LoadMap.h:42
Defragmentation of IndexMaps.
Definition: GA_Defragment.h:45
int capacity() const
Return the capacity of the blob container.
Definition: GA_ATIBlob.h:177
const GA_AttributeType & getType() const
Definition: GA_Attribute.h:204
GA_BlobRef getOrderedBlob(exint idx) const
Lookup a blob given an ordered index.
Definition: GA_ATIBlob.h:233
GA_PageArray< int32 > HandleArrayType
Definition: GA_ATIBlob.h:399
A map of string to various well defined value types.
Definition: UT_Options.h:84
virtual ~GA_BlobDataLoader()
Definition: GA_ATIBlob.h:59
const GA_AIFBlob * getAIFBlob() const override
Return the attribute's blob interface or NULL.
Definition: GA_ATIBlob.h:249
static SYS_FORCE_INLINE bool isType(const GA_Attribute *attrib)
Definition: GA_ATIBlob.h:103
fpreal64 fpreal
Definition: SYS_Types.h:277
bool copy(const GA_Range &destrange, const GA_ATIBlob &src, const GA_Range &srcrange)
Definition: GA_ATIBlob.h:368
SYS_FORCE_INLINE GA_BlobRef lookupBlob(GA_BlobIndex handle) const
Definition: GA_ATIBlob.h:224
Concurrent writes to separate pages supported.
Definition: GA_Attribute.h:365
GA_BlobContainer myBlobs
Blob references. This is protected for convenience to sub-classes.
Definition: GA_ATIBlob.h:466
virtual void compactStorage()
int extractBlobs(UT_Array< GA_BlobRef > &blobs, UT_IntArray &handles) const
Definition: GA_ATIBlob.h:284
const GA_AIFMerge * getAIFMerge() const override
Return the attribute's merge interface or NULL.
Definition: GA_ATIBlob.h:250
bool copy(GA_Offset desti, const GA_ATIBlob &src, GA_Offset srci)
Definition: GA_ATIBlob.h:347
static SYS_FORCE_INLINE const GA_AttributeType & getType()
Definition: GA_ATIBlob.h:100
GLenum GLint * range
Definition: glcorearb.h:1924
bool copy(const GA_Range &destrange, const GA_Attribute &src, const GA_Range &srcrange) overridefinal
Definition: GA_ATIBlob.h:361
virtual void destructElement(GA_Offset offset)
Callback invoked if needsDestruction() returns true.
Attribute Interface class to copy attribute data.
GLintptr offset
Definition: glcorearb.h:664
GA_BlobIndex getMaximumIndex() const
Definition: GA_ATIBlob.h:173
static SYS_FORCE_INLINE const UT_StringHolder & getTypeName()
Definition: GA_ATIBlob.h:97
bool copy(GA_Offset desti, GA_Offset srci) overridefinal
Definition: GA_ATIBlob.h:334
virtual void hardenAllPages(GA_Offset start_offset=GA_Offset(0), GA_Offset end_offset=GA_INVALID_OFFSET)=0
virtual void defragment(const GA_Defragment &defrag)=0
GLdouble s
Definition: glew.h:1395
int extractBlobs(UT_Array< GA_BlobRef > &blobs, UT_IntArray &handles, exint maxblobs) const
Definition: GA_ATIBlob.h:289
bool fill(const GA_Range &destrange, const GA_Attribute &src, GA_Offset srci) overridefinal
Definition: GA_ATIBlob.h:381
Container to store blobs of arbitrary data for attributes.
const GA_AIFInterp * getAIFInterp() const override
Return the attribute's interpolation interface or NULL.
Definition: GA_ATIBlob.h:253