TfVariant.h

Go to the documentation of this file.

 
// Copyright (C) 2002-2022, Open Design Alliance (the "Alliance"). 
// All rights reserved. 
// 
// This software and its documentation and related materials are owned by 
// the Alliance. The software may only be incorporated into application 
// programs owned by members of the Alliance, subject to a signed 
// Membership Agreement and Supplemental Software License Agreement with the
// Alliance. The structure and organization of this software are the valuable  
// trade secrets of the Alliance and its suppliers. The software is also 
// protected by copyright law and international treaty provisions. Application  
// programs incorporating this software must include the following statement 
// with their copyright notices:
//   
//   This application incorporates Open Design Alliance software pursuant to a license 
//   agreement with Open Design Alliance.
//   Open Design Alliance Copyright (C) 2002-2022 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
#ifndef __TF_VARIANT_H__
#define __TF_VARIANT_H__
 
#include "RxVariant.h"
#include "Tf/TfExport.h"
#include "OdGUID.h"
 
class OdDbStub;
 
class OdTfVariant;
 
typedef OdArray<OdTfVariant> OdTfVariantArray;
 
typedef OdArray<OdTfVariant> OdTfVariantTuple;
 
class TFCORE_EXPORT OdTfVariant : public OdVariant {
public:
 
  static const OdVariant::TypeFactory* typeFactory(int type);
  
  typedef enum {
    kGUID = OdVariant::kNextType, // A Global Unique Identifier (GUID) data type.
    kEmpty,                       // An empty variant value.
    kDEPRECARED0,                 // A deprecated data type (for compatibility only). Do not use it. Note that there can be other deprecated data types in future releases.
    kDbStubPtr,                   // A raw pointer to a stub.
    kRxObjectWeakPtr,             // A weak pointer to an OdRxObject.
    kTuple,                       // A tuple of variant values of one data type.
    kNextType                     // A system data type (for internal use only).
  } Type;
 
  static Type kVariantArray(OdUInt16 nDims, OdUInt32 itemType);
  
  static Type kVariantArray(OdUInt16 nDims, OdTfVariant::Type itemType);
  
  static Type kVariantArray(OdUInt32 itemType);
  
  static Type kVariantArray(OdTfVariant::Type type);
 
  static Type getItemType(OdTfVariant::Type type);
  
  static OdUInt16 getDimsCount(OdTfVariant::Type type);
  
  static OdTfVariant empty();
 
  bool isEmpty() const;
  
  bool isVariantArray() const;
 
  OdTfVariant();
  
  OdTfVariant(const OdVariant& value);
  
  OdTfVariant(const OdTfVariant& value);
  
  OdTfVariant(const OdGUID& value);
  
  OdTfVariant(const OdTfVariantTuple& value);
  
  OdTfVariant(OdTfVariant::Type type, const OdTfVariantArray& value);
  
  OdTfVariant(OdDbStub* const value);
 
  OdTfVariant& operator =(const OdTfVariant& value);
 
  virtual ~OdTfVariant();
  
  const OdGUID& getGUID() const;
  
  const OdTfVariantArray& getVariantArray() const;
  
  OdDbStub* getDbStubPtr() const;
  
  OdRxObject* getRxObjectWeakPtr() const;
  
  const OdTfVariantTuple& getVariantTuple() const;
 
  OdTfVariantArray& asVariantArray();
  
  OdTfVariantTuple& asVariantTuple();
 
  OdTfVariant& setGUID(const OdGUID& value);
  
  OdTfVariant& setVariantArray(OdTfVariant::Type type, const OdTfVariantArray& value);
  
  OdTfVariant& setVariantTuple(const OdTfVariantTuple& value);
  
  OdTfVariant& setDbStubPtr(OdDbStub* const value);
  
  OdTfVariant& setRxObjectWeakPtr(OdRxObject* const value);
 
//DOM-IGNORE-BEGIN
protected:
  void setVarType(int newType, int& type, void* data);
  void makeEmpty();
//DOM-IGNORE-END
};
 
inline bool operator==(OdTfVariant::Type lhs, OdVariant::Type rhs) {
  return lhs == static_cast<OdTfVariant::Type>(rhs);
}
 
inline bool operator!=(OdTfVariant::Type lhs, OdVariant::Type rhs) {
  return !(lhs == rhs);
}
 
inline bool operator==(OdVariant::Type lhs, OdTfVariant::Type rhs) {
  return rhs == lhs;
}
 
inline bool operator!=(OdVariant::Type lhs, OdTfVariant::Type rhs) {
  return rhs != lhs;
}
 
#endif