OdDgResBuf.cs

Go to the documentation of this file.

//------------------------------------------------------------------------------
// <auto-generated />
//
// This file was automatically generated by SWIG (http://www.swig.org).
// Version 4.0.2
//
// Do not make changes to this file unless you know what you are doing--modify
// the SWIG interface file instead.
//------------------------------------------------------------------------------
 
namespace Teigha.TG {
 
using System;
using System.Runtime.InteropServices;
using Teigha.Core;
 
public class OdDgResBuf : OdRxObject {
  private Object locker = new Object();
  private HandleRef swigCPtr;
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
  public OdDgResBuf(IntPtr cPtr, bool cMemoryOwn) : base(TG_DbPINVOKE.OdDgResBuf_SWIGUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }
 
  [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)] 
  public static HandleRef getCPtr(OdDgResBuf obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }
 
  protected override void Dispose(bool disposing) {
    lock(this) {
      if (swigCPtr.Handle != global::System.IntPtr.Zero) {
        if (swigCMemOwn) {
          swigCMemOwn = false;
          TG_DbPINVOKE.delete_OdDgResBuf(swigCPtr);
        }
        swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
      }
      base.Dispose(disposing);
    }
  }
 
  public static OdDgResBuf cast(OdRxObject pObj) {//  OdSmartPtr<OdDgResBuf>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_cast(OdRxObject.getCPtr(pObj));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public new static OdRxClass desc() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TG_DbPINVOKE.OdDgResBuf_desc(),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxClass isA() { 
     OdRxClass ret = (OdRxClass)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxClass),TG_DbPINVOKE.OdDgResBuf_isA(swigCPtr),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public override OdRxObject queryX(OdRxClass protocolClass) { 
     OdRxObject ret = (OdRxObject)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdRxObject),TG_DbPINVOKE.OdDgResBuf_queryX(swigCPtr, OdRxClass.getCPtr(protocolClass)),false);  /*createInt 3_2*/
     
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
}
 
  public static OdDgResBuf createObject() {//  OdSmartPtr<OdDgResBuf>
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_createObject();
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public override void copyFrom(OdRxObject pRb) {
    TG_DbPINVOKE.OdDgResBuf_copyFrom(swigCPtr, OdRxObject.getCPtr(pRb));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool IsEqual(OdDgResBuf Rb) {
    bool ret = TG_DbPINVOKE.OdDgResBuf_IsEqual(swigCPtr, OdDgResBuf.getCPtr(Rb));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public bool IsNotEqual(OdDgResBuf Rb) {
    bool ret = TG_DbPINVOKE.OdDgResBuf_IsNotEqual(swigCPtr, OdDgResBuf.getCPtr(Rb));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public int restype() {
    int ret = TG_DbPINVOKE.OdDgResBuf_restype(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setRestype(int resType) {
    TG_DbPINVOKE.OdDgResBuf_setRestype(swigCPtr, resType);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgResBuf next() {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_next(swigCPtr);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDgResBuf last() {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_last(swigCPtr);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDgResBuf insert(OdDgResBuf pRb) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_insert(swigCPtr, OdDgResBuf.getCPtr(pRb));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public OdDgResBuf setNext(OdDgResBuf pRb) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_setNext(swigCPtr, OdDgResBuf.getCPtr(pRb));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public String getString() {
  string ret = TG_DbPINVOKE.OdDgResBuf_getString(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  return ret;
}
 
  public void setString(String sValue) {
    TG_DbPINVOKE.OdDgResBuf_setString(swigCPtr, sValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public bool getBool() {
    bool ret = TG_DbPINVOKE.OdDgResBuf_getBool(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setBool(bool bValue) {
    TG_DbPINVOKE.OdDgResBuf_setBool(swigCPtr, bValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public sbyte getInt8() { 
// test csout
 /*SIMPLETYPE*/
     sbyte ret = TG_DbPINVOKE.OdDgResBuf_getInt8(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setInt8(sbyte /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgResBuf_setInt8(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Int16 getInt16() { 
// test csout
 /*SIMPLETYPE*/
     Int16 ret = TG_DbPINVOKE.OdDgResBuf_getInt16(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setInt16(Int16 /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgResBuf_setInt16(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Int32 getInt32() { 
// test csout
 /*SIMPLETYPE*/
     Int32 ret = TG_DbPINVOKE.OdDgResBuf_getInt32(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setInt32(Int32 /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgResBuf_setInt32(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public Int64 getInt64() { 
// test csout
 /*SIMPLETYPE*/
     Int64 ret = TG_DbPINVOKE.OdDgResBuf_getInt64(swigCPtr); 
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
     return ret;
   }
 
  public void setInt64(Int64 /*SIMPLETYPE*/ iValue) {
    TG_DbPINVOKE.OdDgResBuf_setInt64(swigCPtr, iValue /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public double getDouble() {
    double ret = TG_DbPINVOKE.OdDgResBuf_getDouble(swigCPtr);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setDouble(double realValue) {
    TG_DbPINVOKE.OdDgResBuf_setDouble(swigCPtr, realValue);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint2d getPoint2d() {
    OdGePoint2d ret = new OdGePoint2d(TG_DbPINVOKE.OdDgResBuf_getPoint2d(swigCPtr), false);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setPoint2d(OdGePoint2d gePoint) {
    TG_DbPINVOKE.OdDgResBuf_setPoint2d(swigCPtr, OdGePoint2d.getCPtr(gePoint));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGePoint3d getPoint3d() {
    OdGePoint3d ret = new OdGePoint3d(TG_DbPINVOKE.OdDgResBuf_getPoint3d(swigCPtr), false);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setPoint3d(OdGePoint3d gePoint) {
    TG_DbPINVOKE.OdDgResBuf_setPoint3d(swigCPtr, OdGePoint3d.getCPtr(gePoint));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeVector2d getVector2d() {
    OdGeVector2d ret = new OdGeVector2d(TG_DbPINVOKE.OdDgResBuf_getVector2d(swigCPtr), false);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setVector2d(OdGeVector2d geVector) {
    TG_DbPINVOKE.OdDgResBuf_setVector2d(swigCPtr, OdGeVector2d.getCPtr(geVector).Handle);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdGeVector3d getVector3d() {
    OdGeVector3d ret = new OdGeVector3d(TG_DbPINVOKE.OdDgResBuf_getVector3d(swigCPtr), false);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setVector3d(OdGeVector3d val) {
    TG_DbPINVOKE.OdDgResBuf_setVector3d(swigCPtr, OdGeVector3d.getCPtr(val));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdBinaryData getBinaryChunk() {
    OdBinaryData ret = new OdBinaryData(TG_DbPINVOKE.OdDgResBuf_getBinaryChunk(swigCPtr), false);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setBinaryChunk(OdBinaryData bChunk) {
    TG_DbPINVOKE.OdDgResBuf_setBinaryChunk(swigCPtr, OdBinaryData.getCPtr(bChunk).Handle);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDgResBuf getResBuf() {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_getResBuf(swigCPtr);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public void setResBuf(OdDgResBuf pResBuf) {
    TG_DbPINVOKE.OdDgResBuf_setResBuf(swigCPtr, OdDgResBuf.getCPtr(pResBuf));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public OdDbHandle getHandle() {
    OdDbHandle ret = new OdDbHandle(TG_DbPINVOKE.OdDgResBuf_getHandle(swigCPtr), true);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public void setHandle(OdDbHandle vHandle) {
    TG_DbPINVOKE.OdDgResBuf_setHandle(swigCPtr, OdDbHandle.getCPtr(vHandle));
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public static OdDgResBuf newRb(int resType) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_0(resType);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb() {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_1();
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, bool resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_2(resType, resVal);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, sbyte /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_3(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, byte /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_4(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, Int16 /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_5(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, UInt16 /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_6(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, Int32 /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_7(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, UInt32 /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_8(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, Int64 /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_9(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, UInt64 /*SIMPLETYPE*/ resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_10(resType, resVal /*SIMPLETYPE*/);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, double resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_11(resType, resVal);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, OdGePoint2d resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_12(resType, OdGePoint2d.getCPtr(resVal));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, OdGePoint3d resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_13(resType, OdGePoint3d.getCPtr(resVal));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, OdGeVector2d resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_14(resType, OdGeVector2d.getCPtr(resVal).Handle);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, OdGeVector3d resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_15(resType, OdGeVector3d.getCPtr(resVal));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, String resVal) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_16(resType, resVal);
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static OdDgResBuf newRb(int resType, OdDgResBuf pNestedRb) {//  OdDgResBufPtr
      MemoryManager mMan = MemoryManager.GetMemoryManager();
      MemoryTransaction mTrans = mMan.GetCurrentTransaction(); // MemoryTransaction #17
          IntPtr ptr = TG_DbPINVOKE.OdDgResBuf_newRb__SWIG_17(resType, OdDgResBuf.getCPtr(pNestedRb));
 
          OdDgResBuf ret = null;
          if (null != mTrans)
          {
                mTrans.AddObject((OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true));
                ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, false);
          }
          else
          {
                  ret = (OdDgResBuf)Teigha.Core.Helpers.odrxCreateObjectInternalUniversal(typeof(OdDgResBuf),ptr, true);
          }
          
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
          return ret;
}
 
  public static void setAssertIndexByNewRb(int index) {
    TG_DbPINVOKE.OdDgResBuf_setAssertIndexByNewRb(index);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
  }
 
  public class Data : global::System.IDisposable {
    private Object locker = new Object();
    private HandleRef swigCPtr;
    protected bool swigCMemOwn;
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public Data(IntPtr cPtr, bool cMemoryOwn) {
      swigCMemOwn = cMemoryOwn;
      swigCPtr = new HandleRef(this, cPtr);
    }
    [System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
    public static HandleRef getCPtr(Data obj) {
      return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
    }
  
    ~Data() {
      Dispose(false);
    }
  
    public void Dispose() {
      Dispose(true);
      global::System.GC.SuppressFinalize(this);
    }
  
    protected virtual void Dispose(bool disposing) {
      lock(this) {
        if (swigCPtr.Handle != global::System.IntPtr.Zero) {
          if (swigCMemOwn) {
            swigCMemOwn = false;
            TG_DbPINVOKE.delete_OdDgResBuf_Data(swigCPtr); // NESTED_DTOR_CSHARP
          }
          swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
        }
      }
    }
  
    public bool Bool {
      set {
        TG_DbPINVOKE.OdDgResBuf_Data_Bool_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        bool ret = TG_DbPINVOKE.OdDgResBuf_Data_Bool_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public Int16 Int16 {
      set {
       /*SIMPLETYPE*/
        TG_DbPINVOKE.OdDgResBuf_Data_Int16_set(swigCPtr, value /*SIMPLETYPE*/);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
       /*SIMPLETYPE*/
        Int16 ret = TG_DbPINVOKE.OdDgResBuf_Data_Int16_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public Int32 Int32 {
      set {
       /*SIMPLETYPE*/
        TG_DbPINVOKE.OdDgResBuf_Data_Int32_set(swigCPtr, value /*SIMPLETYPE*/);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
       /*SIMPLETYPE*/
        Int32 ret = TG_DbPINVOKE.OdDgResBuf_Data_Int32_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public Int64 Int64 {
      set {
       /*SIMPLETYPE*/
        TG_DbPINVOKE.OdDgResBuf_Data_Int64_set(swigCPtr, value /*SIMPLETYPE*/);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
       /*SIMPLETYPE*/
        Int64 ret = TG_DbPINVOKE.OdDgResBuf_Data_Int64_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public double Double {
      set {
        TG_DbPINVOKE.OdDgResBuf_Data_Double_set(swigCPtr, value);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        double ret = TG_DbPINVOKE.OdDgResBuf_Data_Double_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public IntPtr Pointer {
      set {
       /*SIMPLETYPE*/
        TG_DbPINVOKE.OdDgResBuf_Data_Pointer_set(swigCPtr, value /*SIMPLETYPE*/);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
       /*SIMPLETYPE*/
        IntPtr ret = TG_DbPINVOKE.OdDgResBuf_Data_Pointer_get(swigCPtr);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public SWIGTYPE_p_unsigned_char Bytes {
      set {
        TG_DbPINVOKE.OdDgResBuf_Data_Bytes_set(swigCPtr, SWIGTYPE_p_unsigned_char.getCPtr(value));
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
      } 
      get {
        global::System.IntPtr cPtr = TG_DbPINVOKE.OdDgResBuf_Data_Bytes_get(swigCPtr);
        SWIGTYPE_p_unsigned_char ret = (cPtr == global::System.IntPtr.Zero) ? null : new SWIGTYPE_p_unsigned_char(cPtr, false);
        if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
        return ret;
      } 
    }
  
    public Data() : this(TG_DbPINVOKE.new_OdDgResBuf_Data(), true) {
      if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    }
  
  }
 
  protected static string getRealClassName(IntPtr /*SIMPLETYPE*/ ptr) {
    string ret = TG_DbPINVOKE.OdDgResBuf_getRealClassName(ptr /*SIMPLETYPE*/);
    if (TG_DbPINVOKE.SWIGPendingException.Pending) throw TG_DbPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }
 
  public enum ValueType {
    kRtNone = 5000,
    kRtDouble = 5001,
    kRtPoint2d = 5002,
    kRtInt16 = 5003,
    kRtAngle = 5004,
    kRtString = 5005,
    kRtEntName = 5006,
    kRtPickSet = 5007,
    kRtOrient = 5008,
    kRtPoint3d = 5009,
    kRtInt32 = 5010,
    kRtColor = 5011,
    kRtVoid = 5014,
    kRtListBeg = 5016,
    kRtListEnd = 5017,
    kRtDote = 5018,
    kRtNil = 5019,
    kRtDXF0 = 5020,
    kRtT = 5021,
    kRtResBuf = 5023,
    kRtBool = 290,
    kRtInt8 = 280,
    kRtVector2d = kRtPoint2d,
    kRtVector3d = kRtPoint3d,
    kRtBinaryChunk = 310,
    kRtHandle = 320,
    kRtObjectId = 330,
    kRtSoftPointerId = 330,
    kRtHardPointerId = 340,
    kRtSoftOwnershipId = 350,
    kRtHardOwnershipId = 360,
    kDxfInvalid = -9999,
    kDxfXDictionary = -6,
    kDxfPReactors = -5,
    kDxfOperator = -4,
    kDxfXDataStart = -3,
    kDxfHeaderId = -2,
    kDxfFirstEntId = -2,
    kDxfEnd = -1,
    kDxfStart = 0,
    kDxfText = 1,
    kDxfXRefPath = 1,
    kDxfShapeName = 2,
    kDxfBlockName = 2,
    kDxfAttributeTag = 2,
    kDxfSymbolTableName = 2,
    kDxfMstyleName = 2,
    kDxfSymTableRecName = 2,
    kDxfAttributePrompt = 3,
    kDxfDimStyleName = 3,
    kDxfLinetypeProse = 3,
    kDxfTextFontFile = 3,
    kDxfDescription = 3,
    kDxfDimPostStr = 3,
    kDxfTextBigFontFile = 4,
    kDxfDimAPostStr = 4,
    kDxfCLShapeName = 4,
    kDxfSymTableRecComments = 4,
    kDxfHandle = 5,
    kDxfDimBlk = 5,
    kDxfDimBlk1 = 6,
    kDxfLinetypeName = 6,
    kDxfDimBlk2 = 7,
    kDxfTextStyleName = 7,
    kDxfLayerName = 8,
    kDxfCLShapeText = 9,
    kDxfXCoord = 10,
    kDxfYCoord = 20,
    kDxfZCoord = 30,
    kDxfElevation = 38,
    kDxfThickness = 39,
    kDxfReal = 40,
    kDxfViewportHeight = 40,
    kDxfTxtSize = 40,
    kDxfTxtStyleXScale = 41,
    kDxfViewWidth = 41,
    kDxfViewportAspect = 41,
    kDxfTxtStylePSize = 42,
    kDxfViewLensLength = 42,
    kDxfViewFrontClip = 43,
    kDxfViewBackClip = 44,
    kDxfShapeXOffset = 44,
    kDxfShapeYOffset = 45,
    kDxfViewHeight = 45,
    kDxfShapeScale = 46,
    kDxfPixelScale = 47,
    kDxfLinetypeScale = 48,
    kDxfDashLength = 49,
    kDxfMlineOffset = 49,
    kDxfLinetypeElement = 49,
    kDxfAngle = 50,
    kDxfViewportSnapAngle = 50,
    kDxfViewportTwist = 51,
    kDxfVisibility = 60,
    kDxfLayerLinetype = 61,
    kDxfColor = 62,
    kDxfHasSubentities = 66,
    kDxfViewportVisibility = 67,
    kDxfViewportActive = 68,
    kDxfViewportNumber = 69,
    kDxfInt16 = 70,
    kDxfViewMode = 71,
    kDxfCircleSides = 72,
    kDxfViewportZoom = 73,
    kDxfViewportIcon = 74,
    kDxfViewportSnap = 75,
    kDxfViewportGrid = 76,
    kDxfViewportSnapStyle = 77,
    kDxfViewportSnapPair = 78,
    kDxfRegAppFlags = 71,
    kDxfTxtStyleFlags = 71,
    kDxfLinetypeAlign = 72,
    kDxfLinetypePDC = 73,
    kDxfInt32 = 90,
    kDxfSubclass = 100,
    kDxfEmbeddedObjectStart = 101,
    kDxfControlString = 102,
    kDxfDimVarHandle = 105,
    kDxfUCSOrg = 110,
    kDxfUCSOriX = 111,
    kDxfUCSOriY = 112,
    kDxfXReal = 140,
    kDxfInt64 = 160,
    kDxfXInt16 = 170,
    kDxfNormalX = 210,
    kDxfNormalY = 220,
    kDxfNormalZ = 230,
    kDxfXXInt16 = 270,
    kDxfInt8 = 280,
    kDxfRenderMode = 281,
    kDxfBool = 290,
    kDxfXTextString = 300,
    kDxfBinaryChunk = 310,
    kDxfArbHandle = 320,
    kDxfSoftPointerId = 330,
    kDxfHardPointerId = 340,
    kDxfSoftOwnershipId = 350,
    kDxfHardOwnershipId = 360,
    kDxfLineWeight = 370,
    kDxfPlotStyleNameType = 380,
    kDxfPlotStyleNameId = 390,
    kDxfXXXInt16 = 400,
    kDxfLayoutName = 410,
    kDxfComment = 999,
    kDxfXdAsciiString = 1000,
    kDxfRegAppName = 1001,
    kDxfXdControlString = 1002,
    kDxfXdLayerName = 1003,
    kDxfXdBinaryChunk = 1004,
    kDxfXdHandle = 1005,
    kDxfXdXCoord = 1010,
    kDxfXdYCoord = 1020,
    kDxfXdZCoord = 1030,
    kDxfXdWorldXCoord = 1011,
    kDxfXdWorldYCoord = 1021,
    kDxfXdWorldZCoord = 1031,
    kDxfXdWorldXDisp = 1012,
    kDxfXdWorldYDisp = 1022,
    kDxfXdWorldZDisp = 1032,
    kDxfXdWorldXDir = 1013,
    kDxfXdWorldYDir = 1023,
    kDxfXdWorldZDir = 1033,
    kDxfXdReal = 1040,
    kDxfXdDist = 1041,
    kDxfXdScale = 1042,
    kDxfXdInteger16 = 1070,
    kDxfXdInteger32 = 1071
  }
 
}
 
}