utilcls.h

实现最短路径算法。 实现最短路径算法。

  }
  TVariantT(short* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(I2, src);
  }
  TVariantT(unsigned short* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(UI2, src);
  }
  TVariantT(int* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(I4, src);
  }
  TVariantT(unsigned int* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(UI4, src);
  }
  TVariantT(long* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(I4, src);
  }
  TVariantT(unsigned long* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(UI4, src);
  }
  TVariantT(float* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(R4, src);
  }
  TVariantT(double* src, bool isDate = false)
  {
    ::VariantInit(this);
    if (isDate)
    {
      SET_VTYPE_AND_VARREF(DATE, src);
    }
    else
    {
      SET_VTYPE_AND_VARREF(R8, src);
    }
  }
  TVariantT(CURRENCY* src)
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(CY, src);
  }
  TVariantT(SAFEARRAY** src)
  {
    ::VariantInit(this);
    SetSAFEARRAY(src);
  }
  TVariantT(wchar_t** src)               // VT_BSTR|VT_BYREF
  {
    ::VariantInit(this);
    SET_VTYPE_AND_VARREF(BSTR, src);
  }

  // Helper for SAFEARRAY
  void SetSAFEARRAY(SAFEARRAY *psa)
  {
    VARTYPE _vt;
    ::SafeArrayGetVartype(psa, &_vt);
    vt = VT_ARRAY|_vt;
    V_ARRAY(this) = psa;
  }
  void SetSAFEARRAY(SAFEARRAY **ppsa)
  {
    VARTYPE _vt;
    ::SafeArrayGetVartype(*ppsa, &_vt);
    vt = VT_ARRAY|VT_BYREF|_vt;
    V_ARRAYREF(this) = ppsa;
  }

  // Assignments
  TVariantT& operator =(const TVariantT& rhs)
  {
    if (&rhs != this)
    {
      ::VariantClear(this);
      ::VariantCopy(this, &(const_cast<TVariantT&>(rhs)));
    }
    return *this;
  }
  TVariantT& operator =(bool src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(BOOL, src ? VARIANT_TRUE : VARIANT_FALSE);
    return *this;
  }
  TVariantT& operator =(const TOLEBOOL& src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(BOOL, src ? VARIANT_TRUE : VARIANT_FALSE);
    return *this;
  }
  TVariantT& operator =(char src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(I1, src);
    return *this;
  }
  TVariantT& operator =(signed char src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(I1, src);
    return *this;
  }
  TVariantT& operator =(unsigned char src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(UI1, src);
    return *this;
  }
  TVariantT& operator =(short src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(I2, src);
    return *this;
  }
  TVariantT& operator =(unsigned short src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(UI2, src);
    return *this;
  }
  TVariantT& operator =(int src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(I4, src);
    return *this;
  }
  TVariantT& operator =(unsigned int src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(UI4, src);
    return *this;
  }
  TVariantT& operator =(long src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(I4, src);
    return *this;
  }
  TVariantT& operator =(unsigned long src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(UI4, src);
    return *this;
  }
  TVariantT& operator =(float src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(R4, src);
    return *this;
  }
  TVariantT& operator =(double src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(R8, src);
    return *this;
  }
  TVariantT& operator =(const CURRENCY& src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(CY, src);
    return *this;
  }
  TVariantT& operator =(SAFEARRAY* src)
  {
    ::VariantClear(this);
    SetSAFEARRAY(src);
    return *this;
  }
  TVariantT& operator =(SAFEARRAY& src)
  {
    ::VariantClear(this);
    SetSAFEARRAY(&src);
    return *this;
  }
  TVariantT& operator =(VARIANT& rhs)
  {
    ::VariantClear(this);
    ::VariantCopy(this, &rhs);
    return *this;
  }
  TVariantT& operator =(VARIANT* rhs)
  {
    ::VariantClear(this);
    // Can only have one level of indirection with VT_VARIANT
    //
    if (rhs && rhs->vt != VT_VARIANT && rhs->vt != (VT_VARIANT|VT_BYREF))
    {
      SET_VTYPE_AND_VARREF(VARIANT, rhs);
    }
    else
    {
      ::VariantCopy(this, rhs);
    }
    return *this;
  }
#if defined(SYSVARI_H)
  TVariantT& operator =(const System::Variant& rhs)
  {
    ::VariantClear(this);
    System::Variant v(rhs.Sanitized());
    ::VariantCopy(this, reinterpret_cast<VARIANT*>(&v));
    return *this;
  }
  TVariantT& operator =(System::Variant* rhs)
  {
    ::VariantClear(this);
    // Can only have one level of indirection with VT_VARIANT
    //
    if (rhs && rhs->vt != VT_VARIANT && rhs->vt != (VT_VARIANT|VT_BYREF))
    {
      SET_VTYPE_AND_VARREF(VARIANT, reinterpret_cast<VARIANT*>(rhs));
    }
    else
    {
      ::VariantCopy(this, reinterpret_cast<VARIANT*>(rhs));
    }
    return *this;
  }
#endif
#if defined(DSTRING_H)
  TVariantT& operator=(const AnsiString& src)
  {
    ::VariantClear(this);
    *this = src.c_str();
    return *this;
  }
#endif
#if defined(SYSCURR_H)
  TVariantT& operator=(const Currency& src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(CY, *(reinterpret_cast<tagCY*>(&(const_cast<Currency&>(src).Val))))
    return *this;
  }
#endif
#if defined(SYSTDATE_H)
  TVariantT& operator=(const TDateTime& src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(DATE, src);
    return *this;
  }
#endif
#if defined(WSTRING_H)
  TVariantT& operator=(const WideString& src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(BSTR, src.Copy());
    return *this;
  }
#endif
#if defined(SYSTOBJ_H)
  TVariantT& operator=(const System::DelphiInterface<IDispatch>& src)
  {
    if (!!src)
      src->AddRef();
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(DISPATCH, src/*Relies on fact that DelphiInterface<> does not AddRef when handing out intf.*/);
    return *this;
  }
#endif

  TVariantT& operator =(wchar_t* src)              // BSTR support
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(BSTR, src);
    return *this;
  }
  TVariantT& operator =(IUnknown* src)
  {
    if (src)
      src->AddRef();
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(UNKNOWN, src);
    return *this;
  }
  TVariantT& operator =(IDispatch* src)
  {
    if (src)
      src->AddRef();
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(DISPATCH, src);
    return *this;
  }


  // By ref Assignment
  // NOTE: We cannot take a 'bool*' - the size of VARIANT_BOOL and bool differ
  TVariantT& operator =(TOLEBOOL* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(BOOL, (VARIANT_BOOL*)src);
    return *this;
  }
  TVariantT& operator =(const char* src)           // Treated as pointer Asciiz string
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VAR(BSTR, AnsiToOLESTR(src));
    return *this;
  }
  TVariantT& operator =(signed char* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(I1, reinterpret_cast<char*>(src));
    return *this;
  }
  TVariantT& operator =(unsigned char* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(UI1, src);
    return *this;
  }
  TVariantT& operator =(short* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(I2, src);
    return *this;
  }
  TVariantT& operator =(unsigned short* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(UI2, src);
    return *this;
  }
  TVariantT& operator =(int* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(I4, (long*)src);
    return *this;
  }
  TVariantT& operator =(unsigned int* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(UI4, reinterpret_cast<unsigned long*>(src));
    return *this;
  }
  TVariantT& operator =(long* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(I4, src);
    return *this;
  }
  TVariantT& operator =(unsigned long* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(UI4, src);
    return *this;
  }
  TVariantT& operator =(float* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(R4, src);
    return *this;
  }
  TVariantT& operator =(double* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(R8, src);
    return *this;
  }
  TVariantT& operator =(CURRENCY* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(CY, src);
    return *this;
  }
  TVariantT& operator =(SAFEARRAY** src)
  {
    ::VariantClear(this);
    SetSAFEARRAY(src);
    return *this;
  }
  TVariantT& operator =(BSTR* /*[wchar_t**]*/ src)             // VT_BSTR|VT_BYREF
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(BSTR, src);
    return *this;
  }
  TVariantT& operator =(IUnknown** src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(UNKNOWN, src);
    return *this;
  }
  TVariantT& operator =(IDispatch** src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(DISPATCH, src);
    return *this;
  }

#if defined(SYSCURR_H)
  TVariantT& operator=(Currency* src)
  {
    ::VariantClear(this);
    if(src)
      SET_VTYPE_AND_VARREF(CY, reinterpret_cast<tagCY*>(&(src->Val)));
    return* this;
  }
#endif
#if defined(SYSTDATE_H)
  TVariantT& operator=(TDateTime* src)
  {
    ::VariantClear(this);
    SET_VTYPE_AND_VARREF(DATE, &src->Val);
    return *this;
  }
#endif
#if defined(SYSTOBJ_H)
  TVariantT& operator=(const System::DelphiInterface<IDispatch>* src)
  {
    ::VariantClear(this);
    if (!!src)
      SET_VTYPE_AND_VARREF(DISPATCH, src);
    return *this;
  }
#endif

  HRESULT   ChangeType(VARTYPE vtNew, const VARIANT& src)
  {
    return ::VariantChangeType(this, &src, 0, vtNew);
  }
  HRESULT   ChangeType(VARTYPE vtNew)
  {
    return ::VariantChangeType(this, this, 0, vtNew);
  }

  // Returns pointer to base Variant type when Variant holds other Variant
  //
  TVariantT* GetBaseVariant();

  // Conversion operators
  operator bool() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_BOOL);
    return V_BOOL(&v) != VARIANT_FALSE;
  }
  operator TOLEBOOL() const
  {
    return TOLEBOOL(bool(*this));
  }
  operator char() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_I1);
    return V_I1(&v);
  }
  operator signed char() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_I1);
    return V_I1(&v);
  }
  operator unsigned char() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_UI1);
    return V_UI1(&v);
  }
  operator short() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_I2);
    return V_I2(&v);
  }
  operator unsigned short() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_UI2);
    return V_UI2(&v);
  }
  operator int() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_I4);
    return V_I4(&v);
  }
  operator unsigned int() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_UI4);
    return V_UI4(&v);
  }
  operator long() const
  {
    TVariantT v(*this);
    v.ChangeType(VT_I4);