GiVariant.h

Go to the documentation of this file.

// Copyright (C) 2002-2017, 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 Teigha(R) software pursuant to a license 
//   agreement with Open Design Alliance.
//   Teigha(R) Copyright (C) 2002-2017 by Open Design Alliance. 
//   All rights reserved.
//
// By use of this software, its documentation or related materials, you 
// acknowledge and accept the above terms.
 
// OdGiVariant type for generic procedural material.
 
#ifndef __ODGIVARIANT_H__
#define __ODGIVARIANT_H__
 
#include "RootExport.h"
#include "GiExport.h"
 
#include "CmColorBase.h"
#include "RxVariant.h"
#include "RxObject.h"
 
#include "TD_PackPush.h"
 
class FIRSTDLL_EXPORT OdGiVariant : public OdRxObject
{
  static void copyDataFrom(OdGiVariant &vTo, const OdGiVariant &vFrom);
  public:
    enum VariantType
    {
      kUndefined = 0, // Variant type is undefined (the default type). 
      kBoolean,       // An OdGiVariant is of a boolean type (bool).
      kInt,           // An OdGiVariant is of a long type (OdInt32).
      kDouble,        // An OdGiVariant is of a double type (double).
      kColor,         // An OdGiVariant is of a color type (OdCmEntityColor).
      kString,        // An OdGiVariant is of a string type (OdString).
      kTable          // An OdGiVariant is a table of key/value pairs.
    };
  public:
    class EnumType
    {
      public:
        explicit EnumType(int value) : m_value(value) { }
        template <typename T> operator T() { return static_cast<T>(m_value); }
        template <typename T> bool operator ==(T right) const { return static_cast<int>(right) == m_value; }
        template <typename T> bool operator !=(T right) const { return !(*this == right); }
      protected:
        int m_value;
    };
  public:
    ODRX_DECLARE_MEMBERS(OdGiVariant);
 
    // Constructors
    //OdGiVariant();
    //OdGiVariant(const OdGiVariant &value);
    //OdGiVariant(bool value);
    //OdGiVariant(OdInt32 value);
    //OdGiVariant(double value);
    //OdGiVariant(const OdCmEntityColor &value);
    //OdGiVariant(const OdString &value);
    //OdGiVariant(const OdChar *value);
  protected:
    OdGiVariant();
  public:
      static OdSmartPtr<OdGiVariant> createObject(const OdGiVariant &value);
    
     static OdSmartPtr<OdGiVariant> createObject(bool value);
 
     static OdSmartPtr<OdGiVariant> createObject(OdInt32 value);
 
    static OdSmartPtr<OdGiVariant> createObject(double value);
 
    static OdSmartPtr<OdGiVariant> createObject(const OdCmEntityColor &value);
 
    static OdSmartPtr<OdGiVariant> createObject(const OdString &value);
 
    static OdSmartPtr<OdGiVariant> createObject(const OdChar *value);
 
    ~OdGiVariant();
 
    bool operator ==(const OdGiVariant& value) const;
 
    OdGiVariant &operator =(const OdGiVariant& value);
 
    virtual void copyFrom(const OdRxObject* pSource);
    
    VariantType type() const;
 
    void set(bool value);
 
    void set(OdInt32 value);
 
    void set(double value);
 
    void set(const OdCmEntityColor &value);
 
    void set(const OdString &value);
    
    void set(const OdChar *value);
 
    bool asBoolean() const;
 
    OdInt32 asInt() const;
 
    double asDouble() const;
 
    const OdCmEntityColor &asColor() const;
 
    const OdString &asString() const;
 
    float asFloat() const;
 
    OdInt8 asChar() const;
 
    OdUInt8 asUchar() const;
 
    OdInt16 asShort() const;
    
    OdUInt16 asUshort() const;
    
    OdUInt32 asUint() const;
    
    OdInt32 asLong() const;
 
    OdUInt32 asUlong() const;
 
    EnumType asEnum() const;
 
    bool getElem(const OdString &elem, OdGiVariant &value) const;
    
    const OdGiVariant *getElem(const OdString &elem) const;
    
    void setElem(const OdString &elem, const OdGiVariant &value);
 
    void deleteElem(const OdString &elem);
 
    OdInt32 getElemCount() const;
 
    bool getElemAt(OdInt32 nElem, OdString &elem, OdGiVariant &value) const;
 
    const OdGiVariant *getElemAt(OdInt32 nElem, OdString &elem) const;
 
    static bool isEquivalent(const OdGiVariant *v1, const OdGiVariant *v2);
  private:
    VariantType m_type;
    OdVariant m_variant;
};
 
template <typename T>
inline bool operator ==(T left, const OdGiVariant::EnumType right)
{
  return (right == left);
}
 
template <typename T>
inline bool operator !=(T left, const OdGiVariant::EnumType right)
{
  return (right != left);
}
 
typedef OdSmartPtr<OdGiVariant> OdGiVariantPtr;
 
#include "TD_PackPop.h"
 
#endif // __ODGIVARIANT_H__