VariantArray

Introduction

An array holding vtkVariants.

Methods

extend

Method used to decorate a given object (publicAPI+model) with vtkVariantArray characteristics.

Argument	Type	Required	Description
publicAPI		Yes	object on which methods will be bounds (public)
model		Yes	object on which data structure will be bounds (protected)
initialValues	IVariantArrayInitialValues	Yes	(default: {})

getComponent

Get the data component at the location specified by tupleIdx and compIdx.

Argument	Type	Required	Description
tupleIdx	Number	Yes
compIdx	Number	No

getData

getDataType

getName

getNumberOfComponents

getNumberOfTuples

getNumberOfValues

getTuple

Argument	Type	Required	Description
idx	Number	Yes
tupleToFill	Array.	No

getTupleLocation

Argument	Type	Required	Description
idx	Number	No

newClone

newInstance

Method used to create a new instance of vtkVariantArray

Argument	Type	Required	Description
initialValues	IVariantArrayInitialValues	Yes	for pre-setting some of its content

setComponent

Set the data component at the location specified by tupleIdx and compIdx
to value.
Note that i is less than NumberOfTuples and j is less than
NumberOfComponents. Make sure enough memory has been allocated
(use SetNumberOfTuples() and SetNumberOfComponents()).

Argument	Type	Required	Description
tupleIdx	Number	Yes
compIdx	Number	Yes
value	String	Yes

setData

Argument	Type	Required	Description
array	Array.	Yes
numberOfComponents	Number	Yes

setName

Source

index.d.ts

import { vtkObject } from '../../../interfaces';

/**
 *
 */
export interface IVariantArrayInitialValues {
  name?: string;
  numberOfComponents?: number;
  size: number;
  dataType?: string;
}

export interface vtkVariantArray extends vtkObject {
  /**
   * Get the data component at the location specified by tupleIdx and compIdx.
   * @param {Number} tupleIdx
   * @param {Number} [compIdx]
   */
  getComponent(tupleIdx: number, compIdx?: number): void;

  /**
   *
   */
  getData(): Array<any>;

  /**
   *
   */
  getDataType(): string;

  /**
   *
   */
  getName(): string;

  /**
   *
   */
  getNumberOfComponents(): number;

  /**
   *
   */
  getNumberOfValues(): number;

  /**
   *
   */
  getNumberOfTuples(): number;

  /**
   *
   * @param {Number} idx
   * @param {Array<any>} [tupleToFill]
   */
  getTuple(idx: number, tupleToFill?: Array<any>): Array<any>;

  /**
   *
   * @param {Number} [idx]
   */
  getTupleLocation(idx?: number): number;

  /**
   *
   */
  newClone(): void;

  /**
   * Set the data component at the location specified by tupleIdx and compIdx
   * to value.
   * Note that i is less than NumberOfTuples and j is less than
   *  NumberOfComponents. Make sure enough memory has been allocated
   * (use SetNumberOfTuples() and SetNumberOfComponents()).
   * @param {Number} tupleIdx
   * @param {Number} compIdx
   * @param {String} value
   */
  setComponent(tupleIdx: number, compIdx: number, value: string): void;

  /**
   *
   * @param {Array<any>} array
   * @param {Number} numberOfComponents
   */
  setData(array: Array<any>, numberOfComponents: number): void;

  /**
   *
   */
  setName(name: string): boolean;
}

/**
 * Method used to decorate a given object (publicAPI+model) with vtkVariantArray characteristics.
 *
 * @param publicAPI object on which methods will be bounds (public)
 * @param model object on which data structure will be bounds (protected)
 * @param {IVariantArrayInitialValues} initialValues (default: {})
 */
export function extend(
  publicAPI: object,
  model: object,
  initialValues: IVariantArrayInitialValues
): void;

/**
 * Method used to create a new instance of vtkVariantArray
 * @param {IVariantArrayInitialValues} initialValues for pre-setting some of its content
 */
export function newInstance(
  initialValues: IVariantArrayInitialValues
): vtkVariantArray;

/**
 * An array holding vtkVariants.
 */
export declare const vtkVariantArray: {
  newInstance: typeof newInstance;
  extend: typeof extend;
};
export default vtkVariantArray;

index.js

import macro from 'vtk.js/Sources/macros';

// ----------------------------------------------------------------------------
// vtkVariantArray methods
// ----------------------------------------------------------------------------

function vtkVariantArray(publicAPI, model) {
  // Set our className
  model.classHierarchy.push('vtkVariantArray');

  // Description:
  // Return the data component at the location specified by tupleIdx and
  // compIdx.
  publicAPI.getComponent = (tupleIdx, compIdx = 0) =>
    model.values[tupleIdx * model.numberOfComponents + compIdx];

  // Description:
  // Set the data component at the location specified by tupleIdx and compIdx
  // to value.
  // Note that i is less than NumberOfTuples and j is less than
  //  NumberOfComponents. Make sure enough memory has been allocated
  // (use SetNumberOfTuples() and SetNumberOfComponents()).
  publicAPI.setComponent = (tupleIdx, compIdx, value) => {
    if (value !== model.values[tupleIdx * model.numberOfComponents + compIdx]) {
      model.values[tupleIdx * model.numberOfComponents + compIdx] = value;
      publicAPI.modified();
    }
  };

  publicAPI.getData = () => model.values;

  publicAPI.getTuple = (idx, tupleToFill = []) => {
    const numberOfComponents = model.numberOfComponents || 1;
    if (tupleToFill.length) {
      tupleToFill.length = numberOfComponents;
    }
    const offset = idx * numberOfComponents;
    for (let i = 0; i < numberOfComponents; i++) {
      tupleToFill[i] = model.values[offset + i];
    }
    return tupleToFill;
  };

  publicAPI.getTupleLocation = (idx = 1) => idx * model.numberOfComponents;
  publicAPI.getNumberOfComponents = () => model.numberOfComponents;
  publicAPI.getNumberOfValues = () => model.values.length;
  publicAPI.getNumberOfTuples = () =>
    model.values.length / model.numberOfComponents;
  publicAPI.getDataType = () => model.dataType;
  /* eslint-disable no-use-before-define */
  publicAPI.newClone = () =>
    newInstance({
      name: model.name,
      numberOfComponents: model.numberOfComponents,
    });
  /* eslint-enable no-use-before-define */

  publicAPI.getName = () => {
    if (!model.name) {
      publicAPI.modified();
      model.name = `vtkVariantArray${publicAPI.getMTime()}`;
    }
    return model.name;
  };

  publicAPI.setData = (array, numberOfComponents) => {
    model.values = array;
    model.size = array.length;
    if (numberOfComponents) {
      model.numberOfComponents = numberOfComponents;
    }
    if (model.size % model.numberOfComponents !== 0) {
      model.numberOfComponents = 1;
    }
    publicAPI.modified();
  };
}

// ----------------------------------------------------------------------------
// Object factory
// ----------------------------------------------------------------------------

const DEFAULT_VALUES = {
  name: '',
  numberOfComponents: 1,
  size: 0,
  // values: null,
  dataType: 'JSON',
};

// ----------------------------------------------------------------------------

export function extend(publicAPI, model, initialValues = {}) {
  Object.assign(model, DEFAULT_VALUES, initialValues);

  if (!model.empty && !model.values && !model.size) {
    throw new TypeError(
      'Cannot create vtkVariantArray object without: size > 0, values'
    );
  }

  if (!model.values) {
    model.values = [];
  } else if (Array.isArray(model.values)) {
    model.values = [...model.values];
  }

  if (model.values) {
    model.size = model.values.length;
  }

  // Object methods
  macro.obj(publicAPI, model);
  macro.set(publicAPI, model, ['name']);

  // Object specific methods
  vtkVariantArray(publicAPI, model);
}

// ----------------------------------------------------------------------------

export const newInstance = macro.newInstance(extend, 'vtkVariantArray');

// ----------------------------------------------------------------------------

export default { newInstance, extend };