dox/Common/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 "vtkType.h"           // To define type IDs and VTK_TYPE_USE_* flags
#include "vtkSystemIncludes.h" // To define ostream
#include "vtkSetGet.h"         // For vtkNotUsed macro
#include "vtkStdString.h"
#include "vtkUnicodeString.h"

//
// The following should be eventually placed in vtkSetGet.h
//

//BTX
// 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);
//ETX

class vtkStdString;
class vtkUnicodeString;
class vtkObjectBase;
class vtkAbstractArray;
class vtkVariant;
struct vtkVariantLessThan;

//BTX
VTK_COMMON_EXPORT ostream& operator << ( ostream& os, const vtkVariant& val );
//ETX

class VTK_COMMON_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);

#if defined(VTK_TYPE_USE___INT64)

  vtkVariant(__int64 value);
  

  vtkVariant(unsigned __int64 value);
#endif
#if defined(VTK_TYPE_USE_LONG_LONG)


  vtkVariant(long long value);


  vtkVariant(unsigned long long value);
#endif


  vtkVariant(float value);

  vtkVariant(double value);

  vtkVariant(const char* value);

  vtkVariant(vtkStdString value);

  vtkVariant(const vtkUnicodeString& value);

  vtkVariant(vtkObjectBase* value);

  vtkVariant(const vtkVariant &other, unsigned int type);

  const vtkVariant & operator= (const vtkVariant & other);

  bool IsValid() const;

  bool IsString() const;

  bool IsUnicodeString() 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 Is__Int64() const;

  bool IsUnsigned__Int64() const;

  bool IsLongLong() const;

  bool IsUnsignedLongLong() const;

  bool IsVTKObject() const;

  bool IsArray() const;

  unsigned int GetType() const;

  const char* GetTypeAsString() const;

  vtkStdString ToString() const;

  vtkUnicodeString ToUnicodeString() const;


  float ToFloat(bool *valid) const;
  float ToFloat() const {
    return this->ToFloat(0); };
  double ToDouble(bool *valid) const;
  double ToDouble() const {
    return this->ToDouble(0); };
  char ToChar(bool *valid) const;
  char ToChar() const {
    return this->ToChar(0); };
  unsigned char ToUnsignedChar(bool *valid) const;
  unsigned char ToUnsignedChar() const {
    return this->ToUnsignedChar(0); };
  signed char ToSignedChar(bool *valid) const;
  signed char ToSignedChar() const {
    return this->ToSignedChar(0); };
  short ToShort(bool *valid) const;
  short ToShort() const {
    return this->ToShort(0); };
  unsigned short ToUnsignedShort(bool *valid) const;
  unsigned short ToUnsignedShort() const {
    return this->ToUnsignedShort(0); };
  int ToInt(bool *valid) const;
  int ToInt() const {
    return this->ToInt(0); };
  unsigned int ToUnsignedInt(bool *valid) const;
  unsigned int ToUnsignedInt() const {
    return this->ToUnsignedInt(0); };
  long ToLong(bool *valid) const;
  long ToLong() const {
    return this->ToLong(0); };
  unsigned long ToUnsignedLong(bool *valid) const;
  unsigned long ToUnsignedLong() const {
    return this->ToUnsignedLong(0); };
#if defined(VTK_TYPE_USE___INT64)
  __int64 To__Int64(bool *valid) const;
  __int64 To__Int64() const {
    return this->To__Int64(0); };
  unsigned __int64 ToUnsigned__Int64(bool *valid) const;
  unsigned __int64 ToUnsigned__Int64() const {
    return this->ToUnsigned__Int64(0); };
#endif
#if defined(VTK_TYPE_USE_LONG_LONG)
  long long ToLongLong(bool *valid) const;
  long long ToLongLong() const {
    return this->ToLongLong(0); };
  unsigned long long ToUnsignedLongLong(bool *valid) const;
  unsigned long long ToUnsignedLongLong() const {
    return this->ToUnsignedLongLong(0); };
#endif
  vtkTypeInt64 ToTypeInt64(bool *valid) const;
  vtkTypeInt64 ToTypeInt64() const {
    return this->ToTypeInt64(0); };
  vtkTypeUInt64 ToTypeUInt64(bool *valid) const;
  vtkTypeUInt64 ToTypeUInt64() const {
    return this->ToTypeUInt64(0); };

  vtkObjectBase* ToVTKObject() const;

  vtkAbstractArray* ToArray() const;

//BTX
  template <typename T>
  T ToNumeric(bool *valid, T* vtkNotUsed(ignored)) const;
//ETX

  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;

//BTX
  friend VTK_COMMON_EXPORT ostream& operator << ( ostream& os, const vtkVariant& val );
//ETX

private:
//BTX
  union
  {
    vtkStdString* String;
    vtkUnicodeString* UnicodeString;
    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;
#if defined(VTK_TYPE_USE___INT64)
    __int64 __Int64;
    unsigned __int64 Unsigned__Int64;
#endif
#if defined(VTK_TYPE_USE_LONG_LONG)
    long long LongLong;
    unsigned long long UnsignedLongLong;
#endif
    vtkObjectBase* VTKObject;
  } Data;

  unsigned char Valid;
  unsigned char Type;

  friend struct vtkVariantLessThan;
  friend struct vtkVariantEqual;
  friend struct vtkVariantStrictWeakOrder;
  friend struct vtkVariantStrictEquality;
//ETX
};

//BTX

#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 VTK_COMMON_EXPORT vtkVariantLessThan
{
public:
  bool operator()(const vtkVariant &s1, const vtkVariant &s2) const;
};

struct VTK_COMMON_EXPORT vtkVariantEqual
{
public:
  bool operator()(const vtkVariant &s1, const vtkVariant &s2) const;
};

struct VTK_COMMON_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 VTK_COMMON_EXPORT vtkVariantStrictEquality
{
public:
  bool operator()(const vtkVariant &s1, const vtkVariant &s2) const;
};

//ETX

#endif