An array holding vtkVariants. More...
#include <vtkVariantArray.h>
Detailed Description
An array holding vtkVariants.
- Thanks:
- Thanks to Patricia Crossno, Ken Moreland, Andrew Wilson and Brian Wylie from Sandia National Laboratories for their help in developing this class.
- Tests:
- vtkVariantArray (Tests)
Definition at line 47 of file vtkVariantArray.h.
Member Typedef Documentation
Reimplemented from vtkAbstractArray.
Definition at line 56 of file vtkVariantArray.h.
Constructor & Destructor Documentation
This destructor is public to work around a bug in version 1.36.0 of the Boost.Serialization library.
| vtkVariantArray::vtkVariantArray | ( | vtkIdType | numComp = 1 | ) | [protected] |
Member Function Documentation
| static vtkVariantArray* vtkVariantArray::New | ( | ) | [static] |
Create an object with Debug turned off, modified time initialized to zero, and reference counting on.
Reimplemented from vtkObject.
| static int vtkVariantArray::IsTypeOf | ( | const char * | name | ) | [static] |
Return 1 if this class type is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h.
Reimplemented from vtkAbstractArray.
| virtual int vtkVariantArray::IsA | ( | const char * | name | ) | [virtual] |
Return 1 if this class is the same type of (or a subclass of) the named class. Returns 0 otherwise. This method works in combination with vtkTypeMacro found in vtkSetGet.h.
Reimplemented from vtkAbstractArray.
| static vtkVariantArray* vtkVariantArray::SafeDownCast | ( | vtkObjectBase * | o | ) | [static] |
Reimplemented from vtkAbstractArray.
| virtual vtkObjectBase* vtkVariantArray::NewInstanceInternal | ( | ) | const [protected, virtual] |
Reimplemented from vtkAbstractArray.
| vtkVariantArray* vtkVariantArray::NewInstance | ( | ) | const |
Reimplemented from vtkAbstractArray.
| void vtkVariantArray::PrintSelf | ( | ostream & | os, |
| vtkIndent | indent | ||
| ) | [virtual] |
Methods invoked by print to print information about the object including superclasses. Typically not called by the user (use Print() instead) but used in the hierarchical print process to combine the output of several classes.
Reimplemented from vtkAbstractArray.
| virtual int vtkVariantArray::Allocate | ( | vtkIdType | sz, |
| vtkIdType | ext = 1000 |
||
| ) | [virtual] |
Allocate memory for this array. Delete old storage only if necessary. Note that ext is no longer used.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::Initialize | ( | ) | [virtual] |
Release storage and reset array to initial state.
Implements vtkAbstractArray.
| virtual int vtkVariantArray::GetDataType | ( | ) | [virtual] |
Return the underlying data type. An integer indicating data type is returned as specified in vtkSetGet.h.
Implements vtkAbstractArray.
| virtual int vtkVariantArray::GetDataTypeSize | ( | ) | [virtual] |
Return the size of the underlying data type. For a bit, 1 is returned. For string 0 is returned. Arrays with variable length components return 0.
Implements vtkAbstractArray.
| virtual int vtkVariantArray::GetElementComponentSize | ( | ) | [virtual] |
Return the size, in bytes, of the lowest-level element of an array. For vtkDataArray and subclasses this is the size of the data type. For vtkStringArray, this is sizeof(vtkStdString::value_type), which winds up being sizeof(char).
Implements vtkAbstractArray.
| virtual void vtkVariantArray::SetNumberOfTuples | ( | vtkIdType | number | ) | [virtual] |
Set the number of tuples (a component group) in the array. Note that this may allocate space depending on the number of components.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::SetTuple | ( | vtkIdType | i, |
| vtkIdType | j, | ||
| vtkAbstractArray * | source | ||
| ) | [virtual] |
Set the tuple at the ith location using the jth tuple in the source array. This method assumes that the two arrays have the same type and structure. Note that range checking and memory allocation is not performed; use in conjunction with SetNumberOfTuples() to allocate space.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::InsertTuple | ( | vtkIdType | i, |
| vtkIdType | j, | ||
| vtkAbstractArray * | source | ||
| ) | [virtual] |
Insert the jth tuple in the source array, at ith location in this array. Note that memory allocation is performed as necessary to hold the data.
Implements vtkAbstractArray.
| virtual vtkIdType vtkVariantArray::InsertNextTuple | ( | vtkIdType | j, |
| vtkAbstractArray * | source | ||
| ) | [virtual] |
Insert the jth tuple in the source array, at the end in this array. Note that memory allocation is performed as necessary to hold the data. Returns the location at which the data was inserted.
Implements vtkAbstractArray.
| virtual void* vtkVariantArray::GetVoidPointer | ( | vtkIdType | id | ) | [virtual] |
Return a void pointer. For image pipeline interface and other special pointer manipulation.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::DeepCopy | ( | vtkAbstractArray * | da | ) | [virtual] |
Deep copy of data. Implementation left to subclasses, which should support as many type conversions as possible given the data type.
Reimplemented from vtkAbstractArray.
| virtual void vtkVariantArray::InterpolateTuple | ( | vtkIdType | i, |
| vtkIdList * | ptIndices, | ||
| vtkAbstractArray * | source, | ||
| double * | weights | ||
| ) | [virtual] |
Set the ith tuple in this array as the interpolated tuple value, given the ptIndices in the source array and associated interpolation weights. This method assumes that the two arrays are of the same type and strcuture.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::InterpolateTuple | ( | vtkIdType | i, |
| vtkIdType | id1, | ||
| vtkAbstractArray * | source1, | ||
| vtkIdType | id2, | ||
| vtkAbstractArray * | source2, | ||
| double | t | ||
| ) | [virtual] |
Insert the ith tuple in this array as interpolated from the two values, p1 and p2, and an interpolation factor, t. The interpolation factor ranges from (0,1), with t=0 located at p1. This method assumes that the three arrays are of the same type. p1 is value at index id1 in source1, while, p2 is value at index id2 in source2.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::Squeeze | ( | ) | [virtual] |
Free any unnecessary memory. Description: Resize object to just fit data requirement. Reclaims extra memory.
Implements vtkAbstractArray.
| virtual int vtkVariantArray::Resize | ( | vtkIdType | numTuples | ) | [virtual] |
Resize the array while conserving the data. Returns 1 if resizing succeeded and 0 otherwise.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::SetVoidArray | ( | void * | arr, |
| vtkIdType | size, | ||
| int | save | ||
| ) | [virtual] |
This method lets the user specify data to be held by the array. The array argument is a pointer to the data. size is the size of the array supplied by the user. Set save to 1 to keep the class from deleting the array when it cleans up or reallocates memory. The class uses the actual array provided; it does not copy the data from the supplied array.
| virtual unsigned long vtkVariantArray::GetActualMemorySize | ( | ) | [virtual] |
Return the memory in kilobytes consumed by this data array. Used to support streaming and reading/writing data. The value returned is guaranteed to be greater than or equal to the memory required to actually represent the data represented by this object. The information returned is valid only after the pipeline has been updated.
Implements vtkAbstractArray.
| virtual int vtkVariantArray::IsNumeric | ( | ) | [virtual] |
Since each item can be of a different type, we say that a variant array is not numeric.
Implements vtkAbstractArray.
| virtual vtkArrayIterator* vtkVariantArray::NewIterator | ( | ) | [virtual] |
Subclasses must override this method and provide the right kind of templated vtkArrayIteratorTemplate.
Implements vtkAbstractArray.
| vtkVariant& vtkVariantArray::GetValue | ( | vtkIdType | id | ) | const |
Get the data at a particular index.
| void vtkVariantArray::SetValue | ( | vtkIdType | id, |
| vtkVariant | value | ||
| ) |
Set the data at a particular index. Does not do range checking. Make sure you use the method SetNumberOfValues() before inserting data.
| void vtkVariantArray::InsertValue | ( | vtkIdType | id, |
| vtkVariant | value | ||
| ) |
If id < GetNumberOfValues(), overwrite the array at that index. If id >= GetNumberOfValues(), expand the array size to id+1 and set the final value to the specified value.
| void vtkVariantArray::SetVariantValue | ( | vtkIdType | idx, |
| vtkVariant | value | ||
| ) | [virtual] |
Insert a value into the array from a variant.
Implements vtkAbstractArray.
Expand the array by one and set the value at that location. Return the array index of the inserted value.
Return a pointer to the location in the internal array at the specified index.
| void vtkVariantArray::SetArray | ( | vtkVariant * | arr, |
| vtkIdType | size, | ||
| int | save | ||
| ) |
Set the internal array used by this object.
| void vtkVariantArray::SetNumberOfValues | ( | vtkIdType | number | ) |
Specify the number of values for this object to hold. Does an allocation as well as setting the MaxId ivar. Used in conjunction with SetValue() method for fast insertion.
| vtkIdType vtkVariantArray::GetNumberOfValues | ( | ) | [inline] |
Return the number of values in the array.
Definition at line 210 of file vtkVariantArray.h.
| virtual vtkIdType vtkVariantArray::LookupValue | ( | vtkVariant | value | ) | [virtual] |
Return the indices where a specific value appears.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::LookupValue | ( | vtkVariant | value, |
| vtkIdList * | ids | ||
| ) | [virtual] |
Return the indices where a specific value appears.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::DataChanged | ( | ) | [virtual] |
Tell the array explicitly that the data has changed. This is only necessary to call when you modify the array contents without using the array's API (i.e. you retrieve a pointer to the data and modify the array contents). You need to call this so that the fast lookup will know to rebuild itself. Otherwise, the lookup functions will give incorrect results.
Implements vtkAbstractArray.
| virtual void vtkVariantArray::DataElementChanged | ( | vtkIdType | id | ) | [virtual] |
Tell the array explicitly that a single data element has changed. Like DataChanged(), then is only necessary when you modify the array contents without using the array's API.
| virtual void vtkVariantArray::ClearLookup | ( | ) | [virtual] |
Delete the associated fast lookup data structure on this array, if it exists. The lookup will be rebuilt on the next call to a lookup function.
Implements vtkAbstractArray.
| vtkVariant* vtkVariantArray::ResizeAndExtend | ( | vtkIdType | sz | ) | [protected] |
Friends And Related Function Documentation
friend class boost::serialization::access [friend] |
Friendship required for Boost serialization.
Definition at line 51 of file vtkVariantArray.h.
Member Data Documentation
vtkVariant* vtkVariantArray::Array [protected] |
Definition at line 246 of file vtkVariantArray.h.
int vtkVariantArray::SaveUserArray [protected] |
Definition at line 252 of file vtkVariantArray.h.
The documentation for this class was generated from the following file:
- dox/Common/Core/vtkVariantArray.h
