ScopedVariant

最新推荐文章于 2024-11-02 11:32:21 发布
最新推荐文章于 2024-11-02 11:32:21 发布
阅读量312 收藏
点赞数
分类专栏： Chrome 文章标签： ui constructor date object function setter
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qinbaoan/article/details/4227804
版权

class ScopedVariant {

 public:

  // Declaration of a global variant variable that's always VT_EMPTY

  static const VARIANT kEmptyVariant;

 

  // Default constructor.

  ScopedVariant() {

    // This is equivalent to what VariantInit does, but less code.

    var_.vt = VT_EMPTY;

  }

 

  // Constructor to create a new VT_BSTR VARIANT.

  // NOTE: Do not pass a BSTR to this constructor expecting ownership to

  // be transferred

  explicit ScopedVariant(const wchar_t* str);

 

  // Creates a new VT_BSTR variant of a specified length.

  explicit ScopedVariant(const wchar_t* str, UINT length);

 

  // Creates a new integral type variant and assigns the value to

  // VARIANT.lVal (32 bit sized field).

  explicit ScopedVariant(int value, VARTYPE vt = VT_I4);

 

  // VT_DISPATCH

  explicit ScopedVariant(IDispatch* dispatch);

 

  // VT_UNKNOWN

  explicit ScopedVariant(IUnknown* unknown);

 

  // Copies the variant.

  explicit ScopedVariant(const VARIANT& var);

 

  ~ScopedVariant();

 

  inline VARTYPE type() const {

    return var_.vt;

  }

 

  // Give ScopedVariant ownership over an already allocated VARIANT.

  void Reset(const VARIANT& var = kEmptyVariant);

 

  // Releases ownership of the VARIANT to the caller.

  VARIANT Release();

 

  // Swap two ScopedVariant's.

  void Swap(ScopedVariant& var);

 

  // Returns a copy of the variant.

  VARIANT Copy() const;

 

  // The return value is 0 if the variants are equal, 1 if this object is

  // greater than |var|, -1 if it is smaller.

  int Compare(const VARIANT& var, bool ignore_case = false) const;

 

  // Retrieves the pointer address.

  // Used to receive a VARIANT as an out argument (and take ownership).

  // The function DCHECKs on the current value being empty/null.

  // Usage: GetVariant(var.receive());

  VARIANT* Receive();

 

  void Set(const wchar_t* str);

 

  // Setters for simple types.

  void Set(int8 i8);

  void Set(uint8 ui8);

  void Set(int16 i16);

  void Set(uint16 ui16);

  void Set(int32 i32);

  void Set(uint32 ui32);

  void Set(int64 i64);

  void Set(uint64 ui64);

  void Set(float r32);

  void Set(double r64);

  void Set(bool b);

 

  // Creates a copy of |var| and assigns as this instance's value.

  // Note that this is different from the Reset() method that's used to

  // free the current value and assume ownership.

  void Set(const VARIANT& var);

 

  // COM object setters

  void Set(IDispatch* disp);

  void Set(IUnknown* unk);

 

  // SAFEARRAY support

  void Set(SAFEARRAY* array);

 

  // Special setter for DATE since DATE is a double and we already have

  // a setter for double.

  void SetDate(DATE date);

 

  // Allows const access to the contained variant without DCHECKs etc.

  // This support is necessary for the V_XYZ (e.g. V_BSTR) set of macros to

  // work properly but still doesn't allow modifications since we want control

  // over that.

  const VARIANT* operator&() const {

    return &var_;

  }

 

  // Like other scoped classes (e.g scoped_refptr, ScopedComPtr, ScopedBstr)

  // we support the assignment operator for the type we wrap.

  ScopedVariant& operator=(const VARIANT& var);

 

  // A hack to pass a pointer to the variant where the accepting

  // function treats the variant as an input-only, read-only value

  // but the function prototype requires a non const variant pointer.

  // There's no DCHECK or anything here.  Callers must know what they're doing.

  VARIANT* AsInput() const {

    // The nature of this function is const, so we declare

    // it as such and cast away the constness here.

    return const_cast<VARIANT*>(&var_);

  }

 

  // Allows the ScopedVariant instance to be passed to functions either by value

  // or by const reference.

  operator const VARIANT&() const {

    return var_;

  }

 

  // Used as a debug check to see if we're leaking anything.

  static bool IsLeakableVarType(VARTYPE vt);

 

 protected:

  VARIANT var_;

 

 private:

  // Comparison operators for ScopedVariant are not supported at this point.

  // Use the Compare method instead.

  bool operator==(const ScopedVariant& var) const;

  bool operator!=(const ScopedVariant& var) const;

  DISALLOW_COPY_AND_ASSIGN(ScopedVariant);

};

// Global, const instance of an empty variant.
const VARIANT ScopedVariant::kEmptyVariant = { VT_EMPTY };
ScopedVariant::~ScopedVariant() {
  COMPILE_ASSERT(sizeof(ScopedVariant) == sizeof(VARIANT), ScopedVariantSize);
  ::VariantClear(&var_);
}
ScopedVariant::ScopedVariant(const wchar_t* str) {
  var_.vt = VT_EMPTY;
  Set(str);
}
ScopedVariant::ScopedVariant(const wchar_t* str, UINT length) {
  var_.vt = VT_BSTR;
  var_.bstrVal = ::SysAllocStringLen(str, length);
}
ScopedVariant::ScopedVariant(int value, VARTYPE vt) {
  var_.vt = vt;
  var_.lVal = value;
}
ScopedVariant::ScopedVariant(IDispatch* dispatch) {
  var_.vt = VT_EMPTY;
  Set(dispatch);
}
ScopedVariant::ScopedVariant(IUnknown* unknown) {
  var_.vt = VT_EMPTY;
  Set(unknown);
}
ScopedVariant::ScopedVariant(const VARIANT& var) {
  var_.vt = VT_EMPTY;
  Set(var);
}
void ScopedVariant::Reset(const VARIANT& var) {
  if (&var != &var_) {
    ::VariantClear(&var_);
    var_ = var;
  }
}
VARIANT ScopedVariant::Release() {
  VARIANT var = var_;
  var_.vt = VT_EMPTY;
  return var;
}
void ScopedVariant::Swap(ScopedVariant& var) {
  VARIANT tmp = var_;
  var_ = var.var_;
  var.var_ = tmp;
}
VARIANT* ScopedVariant::Receive() {
  DCHECK(!IsLeakableVarType(var_.vt)) << "variant leak. type: " << var_.vt;
  return &var_;
}
VARIANT ScopedVariant::Copy() const {
  VARIANT ret = { VT_EMPTY };
  ::VariantCopy(&ret, &var_);
  return ret;
}
int ScopedVariant::Compare(const VARIANT& var, bool ignore_case) const {
  ULONG flags = ignore_case ? NORM_IGNORECASE : 0;
  HRESULT hr = ::VarCmp(const_cast<VARIANT*>(&var_), const_cast<VARIANT*>(&var),
                        LOCALE_USER_DEFAULT, flags);
  int ret = 0;
  switch (hr) {
    case VARCMP_LT:
      ret = -1;
      break;
    case VARCMP_GT:
    case VARCMP_NULL:
      ret = 1;
      break;
    default:
      // Equal.
      break;
  }
  return ret;
}
void ScopedVariant::Set(const wchar_t* str) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_BSTR;
  var_.bstrVal = ::SysAllocString(str);
}
void ScopedVariant::Set(int8 i8) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_I1;
  var_.cVal = i8;
}
void ScopedVariant::Set(uint8 ui8) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_UI1;
  var_.bVal = ui8;
}
void ScopedVariant::Set(int16 i16) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_I2;
  var_.iVal = i16;
}
void ScopedVariant::Set(uint16 ui16) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_UI2;
  var_.uiVal = ui16;
}
void ScopedVariant::Set(int32 i32) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_I4;
  var_.lVal = i32;
}
void ScopedVariant::Set(uint32 ui32) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_UI4;
  var_.ulVal = ui32;
}
void ScopedVariant::Set(int64 i64) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_I8;
  var_.llVal = i64;
}
void ScopedVariant::Set(uint64 ui64) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_UI8;
  var_.ullVal = ui64;
}
void ScopedVariant::Set(float r32) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_R4;
  var_.fltVal = r32;
}
void ScopedVariant::Set(double r64) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_R8;
  var_.dblVal = r64;
}
void ScopedVariant::SetDate(DATE date) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_DATE;
  var_.date = date;
}
void ScopedVariant::Set(IDispatch* disp) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_DISPATCH;
  var_.pdispVal = disp;
  if (disp)
    disp->AddRef();
}
void ScopedVariant::Set(bool b) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_BOOL;
  var_.boolVal = b ? VARIANT_TRUE : VARIANT_FALSE;
}
void ScopedVariant::Set(IUnknown* unk) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  var_.vt = VT_UNKNOWN;
  var_.punkVal = unk;
  if (unk)
    unk->AddRef();
}
void ScopedVariant::Set(SAFEARRAY* array) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  if (SUCCEEDED(::SafeArrayGetVartype(array, &var_.vt))) {
    var_.vt |= VT_ARRAY;
    var_.parray = array;
  } else {
    DCHECK(array == NULL) << "Unable to determine safearray vartype";
    var_.vt = VT_EMPTY;
  }
}
void ScopedVariant::Set(const VARIANT& var) {
  DCHECK(!IsLeakableVarType(var_.vt)) << "leaking variant: " << var_.vt;
  if (FAILED(::VariantCopy(&var_, &var))) {
    DLOG(ERROR) << "VariantCopy failed";
    var_.vt = VT_EMPTY;
  }
}
ScopedVariant& ScopedVariant::operator=(const VARIANT& var) {
  if (&var != &var_) {
    VariantClear(&var_);
    Set(var);
  }
  return *this;
}
bool ScopedVariant::IsLeakableVarType(VARTYPE vt) {
  bool leakable = false;
  switch (vt & VT_TYPEMASK) {
    case VT_BSTR:
    case VT_DISPATCH:
    // we treat VT_VARIANT as leakable to err on the safe side.
    case VT_VARIANT:
    case VT_UNKNOWN:
    case VT_SAFEARRAY:
    // very rarely used stuff (if ever):
    case VT_VOID:
    case VT_PTR:
    case VT_CARRAY:
    case VT_USERDEFINED:
    case VT_LPSTR:
    case VT_LPWSTR:
    case VT_RECORD:
    case VT_INT_PTR:
    case VT_UINT_PTR:
    case VT_FILETIME:
    case VT_BLOB:
    case VT_STREAM:
    case VT_STORAGE:
    case VT_STREAMED_OBJECT:
    case VT_STORED_OBJECT:
    case VT_BLOB_OBJECT:
    case VT_VERSIONED_STREAM:
    case VT_BSTR_BLOB:
      leakable = true;
      break;
  }
  if (!leakable && (vt & VT_ARRAY) != 0) {
    leakable = true;
  }
  return leakable;
}

qinbaoan
关注
专栏目录
RefCountedThreadSafe
技术推测阿堵孔家
05-31 1478
class RefCountedThreadSafeBase { protected:  RefCountedThreadSafeBase();  ~RefCountedThreadSafeBase();   void AddRef();   // Returns true if the object should self-delete.  bool Rele
RefCounted
技术推测阿堵孔家
05-31 739
class RefCountedBase { protected:  RefCountedBase();  ~RefCountedBase();   void AddRef();   // Returns true if the object should self-delete.  bool Release();  private:  int re
【IE编程】 IWebBrowser2子线程调用崩溃
kevin的博客
01-03 495
1.c++调用js函数方法： #include <Mshtml.h> bool CBrowserFunc::ExecJsFun(IWebBrowser2 *pWebBrowser2, const std::wstring& lpJsFun, const std::wstring &json_param) { //程序开始处com是否已经初始化 if (NULL...
implicit_cast
技术推测阿堵孔家
05-31 1924
templateinline To implicit_cast(From const &f) {  return f;}
StringPiece
技术推测阿堵孔家
05-31 1865
class StringPiece { public:  typedef size_t size_type;  private:  const char*   ptr_;  size_type     length_;  public:  // We provide non-explicit singleton constructors so users c
SharedMemory
技术推测阿堵孔家
05-31 896
// SharedMemoryHandle is a platform specific type which represents// the underlying OS handle to a shared memory segment.#if defined(OS_WIN)typedef HANDLE SharedMemoryHandle;typedef HANDLE S
COMPILE_ASSERT
技术推测阿堵孔家
05-31 737
template struct CompileAssert {}; #undef COMPILE_ASSERT#define COMPILE_ASSERT(expr, msg) /  typedef CompileAssert msg[bool(expr) ? 1 : -1]在编译时进行检查，由于struct CompileAssert为空，所以不占字节空间。
ScopedVector
技术推测阿堵孔家
05-31 630
 // ScopedVector wraps a vector deleting the elements from its// destructor.template class ScopedVector { public:  typedef typename std::vector::iterator iterator;  typedef typename std:
SysInfo
技术推测阿堵孔家
05-31 620
class SysInfo { public:  // Return the number of logical processors/cores on the current machine.  // WARNING: On POSIX, this method uses static variables and is not threadsafe  // until it
TimeFormat
技术推测阿堵孔家
05-31 615
// Returns the time of day, e.g., "3:07 PM".std::wstring TimeFormatTimeOfDay(const Time& time); // Returns a shortened date, e.g. "Nov 7, 2007"std::wstring TimeFormatShortDate(const Time& ti
ScopedTempDir
技术推测阿堵孔家
05-31 613
class ScopedTempDir { public:  // No directory is owned/created initially.  ScopedTempDir();   // Recursively delete path_  ~ScopedTempDir();   // Creates a unique directory in TempP
ThreadLocalStorage
技术推测阿堵孔家
05-31 598
class ThreadLocalStorage { public:   // Prototype for the TLS destructor function, which can be optionally used to  // cleanup thread local storage on thread exit.  value is the data that
SystemMonitor
技术推测阿堵孔家
05-31 597
class SystemMonitor { public:  // Access to the Singleton  static SystemMonitor* Get() {    // Uses the LeakySingletonTrait because cleanup is optional.    return        Singleton >::get
scoped_array
技术推测阿堵孔家
05-31 577
template class scoped_array { public:   // The element type  typedef C element_type;   // Constructor.  Defaults to intializing with NULL.  // There is no way to create an uninitiali
Singleton
技术推测阿堵孔家
05-31 548
 // Default traits for Singleton. Calls operator new and operator delete on// the object. Registers automatic deletion at process exit.// Overload if you need arguments or another memory allocat
Timer
技术推测阿堵孔家
05-31 546
class BaseTimer_Helper { public:  // Stops the timer.  ~BaseTimer_Helper() {    OrphanDelayedTask();  }   // Returns true if the timer is running (i.e., not stopped).  bool IsRunning
PyQt5实战——多脚本集合包，UI以及工程布局（二）
LyricalRover的博客
11-01 728
本文主要讲述了作者的UI页面以及工程文件的布局，提前规划好UI页面的布局有利于后续各组件的摆放以及是否要限制组件的大小，设计好工程文件的布局有利于后期维护工程以及减少开发工作量，一些重复性的代码可封装起来，作者介绍了自己工程布局的思想
Flutter 简述(1)
最新发布
起司锅仔的博客
11-02 337
Flutter是Google开源的应用框架，只要一套代码兼顾Android、iOS、Web、Windows、macOS和Linux六个平台，它的设计思路可以说更加先进，不像ReactNative每个组件都需要有对应的原生组件实现，而是通过skia或者其他的渲染引擎来直接渲染画面，Flutter使用dart虚拟机来实现跨平台管理UI。
WPF 行为转命令
qq_44967213的博客
10-30 928
通过将行为转换为命令，可以在WPF应用程序中更加灵活地处理交互行为与业务逻辑之间的关系，充分利用命令的结构化特点和行为的灵活性，提高代码的可维护性和可扩展性。
QT-使用QSS美化UI界面
weixin_42255385的博客
10-24 660
使用QSS实现Qt UI界面背景图添加、Lable控件美化，包含源码及使用方法详细讲解
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值