vtkVariant.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkVariant.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
/*-------------------------------------------------------------------------
  Copyright 2008 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
  the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------*/
#ifndef vtkVariant_h
#define vtkVariant_h
 
#include "vtkCommonCoreModule.h" // For export macro
#include "vtkObject.h"           // For vtkObject's warning support
#include "vtkSetGet.h"           // For vtkNotUsed macro
#include "vtkStdString.h"
#include "vtkSystemIncludes.h" // To define ostream
#include "vtkType.h"           // To define type IDs and VTK_TYPE_USE_* flags
 
//
// The following should be eventually placed in vtkSetGet.h
//
 
// This is same as extended template macro with an additional case for VTK_VARIANT
#define vtkExtraExtendedTemplateMacro(call)                                                        \
  vtkExtendedTemplateMacro(call);                                                                  \
  vtkTemplateMacroCase(VTK_VARIANT, vtkVariant, call)
 
// This is same as Iterator Template macro with an additional case for VTK_VARIANT
#define vtkExtendedArrayIteratorTemplateMacro(call)                                                \
  vtkArrayIteratorTemplateMacro(call);                                                             \
  vtkArrayIteratorTemplateMacroCase(VTK_VARIANT, vtkVariant, call)
 
class vtkStdString;
class vtkObjectBase;
class vtkAbstractArray;
class vtkVariant;
struct vtkVariantLessThan;
 
VTKCOMMONCORE_EXPORT ostream& operator<<(ostream& os, const vtkVariant& val);
 
class VTKCOMMONCORE_EXPORT vtkVariant
{
public:
  vtkVariant();
 
  ~vtkVariant();
 
  vtkVariant(const vtkVariant& other);
 
  vtkVariant(bool value);
 
  vtkVariant(char value);
 
  vtkVariant(unsigned char value);
 
  vtkVariant(signed char value);
 
  vtkVariant(short value);
 
  vtkVariant(unsigned short value);
 
  vtkVariant(int value);
 
  vtkVariant(unsigned int value);
 
  vtkVariant(long value);
 
  vtkVariant(unsigned long value);
 
  vtkVariant(long long value);
 
  vtkVariant(unsigned long long value);
 
  vtkVariant(float value);
 
  vtkVariant(double value);
 
  vtkVariant(const char* value);
 
  vtkVariant(vtkStdString value);
 
  vtkVariant(vtkObjectBase* value);
 
  vtkVariant(const vtkVariant& other, unsigned int type);
 
  vtkVariant& operator=(const vtkVariant& other);
 
  bool IsValid() const;
 
  bool IsString() const;
 
  bool IsNumeric() const;
 
  bool IsFloat() const;
 
  bool IsDouble() const;
 
  bool IsChar() const;
 
  bool IsUnsignedChar() const;
 
  bool IsSignedChar() const;
 
  bool IsShort() const;
 
  bool IsUnsignedShort() const;
 
  bool IsInt() const;
 
  bool IsUnsignedInt() const;
 
  bool IsLong() const;
 
  bool IsUnsignedLong() const;
 
  bool IsLongLong() const;
 
  bool IsUnsignedLongLong() const;
 
  bool IsVTKObject() const;
 
  bool IsArray() const;
 
  unsigned int GetType() const;
 
  const char* GetTypeAsString() const;
 
  enum StringFormatting
  {
    DEFAULT_FORMATTING = 0,
    FIXED_FORMATTING = 1,
    SCIENTIFIC_FORMATTING = 2
  };
 
  vtkStdString ToString(int formatting = DEFAULT_FORMATTING, int precision = 6) const;
 
 
  float ToFloat(bool* valid) const;
  float ToFloat() const { return this->ToFloat(nullptr); }
  double ToDouble(bool* valid) const;
  double ToDouble() const { return this->ToDouble(nullptr); }
  char ToChar(bool* valid) const;
  char ToChar() const { return this->ToChar(nullptr); }
  unsigned char ToUnsignedChar(bool* valid) const;
  unsigned char ToUnsignedChar() const { return this->ToUnsignedChar(nullptr); }
  signed char ToSignedChar(bool* valid) const;
  signed char ToSignedChar() const { return this->ToSignedChar(nullptr); }
  short ToShort(bool* valid) const;
  short ToShort() const { return this->ToShort(nullptr); }
  unsigned short ToUnsignedShort(bool* valid) const;
  unsigned short ToUnsignedShort() const { return this->ToUnsignedShort(nullptr); }
  int ToInt(bool* valid) const;
  int ToInt() const { return this->ToInt(nullptr); }
  unsigned int ToUnsignedInt(bool* valid) const;
  unsigned int ToUnsignedInt() const { return this->ToUnsignedInt(nullptr); }
  long ToLong(bool* valid) const;
  long ToLong() const { return this->ToLong(nullptr); }
  unsigned long ToUnsignedLong(bool* valid) const;
  unsigned long ToUnsignedLong() const { return this->ToUnsignedLong(nullptr); }
  long long ToLongLong(bool* valid) const;
  long long ToLongLong() const { return this->ToLongLong(nullptr); }
  unsigned long long ToUnsignedLongLong(bool* valid) const;
  unsigned long long ToUnsignedLongLong() const { return this->ToUnsignedLongLong(nullptr); }
  vtkTypeInt64 ToTypeInt64(bool* valid) const;
  vtkTypeInt64 ToTypeInt64() const { return this->ToTypeInt64(nullptr); }
  vtkTypeUInt64 ToTypeUInt64(bool* valid) const;
  vtkTypeUInt64 ToTypeUInt64() const { return this->ToTypeUInt64(nullptr); }
 
  vtkObjectBase* ToVTKObject() const;
 
  vtkAbstractArray* ToArray() const;
 
  bool IsEqual(const vtkVariant& other) const;
 
 
  bool operator==(const vtkVariant& other) const;
  bool operator!=(const vtkVariant& other) const;
  bool operator<(const vtkVariant& other) const;
  bool operator>(const vtkVariant& other) const;
  bool operator<=(const vtkVariant& other) const;
  bool operator>=(const vtkVariant& other) const;
 
  friend VTKCOMMONCORE_EXPORT ostream& operator<<(ostream& os, const vtkVariant& val);
 
private:
  template <typename T>
  T ToNumeric(bool* valid, T* vtkNotUsed(ignored)) const;
 
  union {
    vtkStdString* String;
    float Float;
    double Double;
    char Char;
    unsigned char UnsignedChar;
    signed char SignedChar;
    short Short;
    unsigned short UnsignedShort;
    int Int;
    unsigned int UnsignedInt;
    long Long;
    unsigned long UnsignedLong;
    long long LongLong;
    unsigned long long UnsignedLongLong;
    vtkObjectBase* VTKObject;
  } Data;
 
  unsigned char Valid;
  unsigned char Type;
 
  friend struct vtkVariantLessThan;
  friend struct vtkVariantEqual;
  friend struct vtkVariantStrictWeakOrder;
  friend struct vtkVariantStrictEquality;
};
 
#include "vtkVariantInlineOperators.h" // needed for operator== and company
 
// A STL-style function object so you can compare two variants using
// comp(s1,s2) where comp is an instance of vtkVariantStrictWeakOrder.
// This is a faster version of operator< that makes no attempt to
// compare values.  It satisfies the STL requirement for a comparison
// function for ordered containers like map and set.
 
struct VTKCOMMONCORE_EXPORT vtkVariantLessThan
{
public:
  bool operator()(const vtkVariant& s1, const vtkVariant& s2) const;
};
 
struct VTKCOMMONCORE_EXPORT vtkVariantEqual
{
public:
  bool operator()(const vtkVariant& s1, const vtkVariant& s2) const;
};
 
struct VTKCOMMONCORE_EXPORT vtkVariantStrictWeakOrder
{
public:
  bool operator()(const vtkVariant& s1, const vtkVariant& s2) const;
};
 
// Similarly, this is a fast version of operator== that requires that
// the types AND the values be equal in order to admit equality.
 
struct VTKCOMMONCORE_EXPORT vtkVariantStrictEquality
{
public:
  bool operator()(const vtkVariant& s1, const vtkVariant& s2) const;
};
 
#endif
// VTK-HeaderTest-Exclude: vtkVariant.h