sustaining_gazes/lib/local/CamCom/comet/tlbinfo.h
2016-05-20 16:48:43 -04:00

451 lines
16 KiB
C++

/** \file
* Wrappers for ITypeLibInfo.
*/
/*
* Copyright © 2002 Michael Geddes.
*
* This material is provided "as is", with absolutely no warranty
* expressed or implied. Any use is at your own risk. Permission to
* use or copy this software for any purpose is hereby granted without
* fee, provided the above notices are retained on all copies.
* Permission to modify the code and to distribute modified code is
* granted, provided the above notices are retained, and a notice that
* the code was modified is included with the above copyright notice.
*
* This header is part of Comet version 2.
* https://github.com/alamaison/comet
*/
#ifndef COMET_TLIBINFO_H
#define COMET_TLIBINFO_H
#ifdef _SHOW_INC
#pragma message(" #Include " __FILE__)
#endif
#include <oaidl.h>
#include <comet/ptr.h>
#include <comet/uuid.h>
namespace comet
{
template<> struct comtype<ITypeLib>
{
static const IID& uuid() throw() { return IID_IPictureDisp; }
typedef ::IUnknown base;
};
template<> struct comtype<ITypeInfo>
{
static const IID& uuid() throw() { return IID_ITypeInfo; }
typedef ::IUnknown base;
};
template<> struct comtype<ITypeInfo2>
{
static const IID& uuid() throw() { return IID_ITypeInfo2; }
typedef ::ITypeInfo base;
};
/*! \addtogroup Interfaces
*/
//@{
namespace impl
{
/// A class to handle the auto-releaseing of structs returned by by the Typeinfo interfaces.
template< typename B, typename T>
struct tlib_info
{
typedef void (__stdcall B::*RelFunc)(T*);
template< RelFunc RELEASE>
struct typeinfo_attr_base
{
public:
typeinfo_attr_base() : info_(NULL), attrib_(NULL), rc_(NULL) {}
typeinfo_attr_base( const com_ptr<B> &info, T *attrib ) : info_(info),attrib_(attrib),rc_(NULL)
{
if (attrib != NULL)
{
rc_ = new long;
(*rc_)=1;
}
}
typeinfo_attr_base( const typeinfo_attr_base &base)
: info_(base.info_), attrib_(base.attrib_), rc_(base.rc_)
{
++*rc_;
}
~typeinfo_attr_base()
{
release();
}
typeinfo_attr_base &operator =( const typeinfo_attr_base &base)
{
release();
info_= base.info_;
attrib_= base.attrib_;
rc_ = base.rc_;
++*rc_;
return *this;
}
void release()
{
if(attrib_ != NULL && rc_ != NULL )
{
if (0 == --*rc_)
{
(info_.raw()->*RELEASE)( attrib_);
delete rc_;
}
rc_ = NULL;
attrib_ = NULL;
info_ = NULL;
}
}
T *operator->() const
{
if( attrib_ ==NULL ) throw com_error(E_POINTER);
return attrib_;
}
bool is_null() const { return attrib_ == NULL; }
protected:
long *rc_;
T *attrib_;
com_ptr<B> info_;
};
};
};
/// Auto-release wrapper for TYPEATTR.
typedef impl::tlib_info<ITypeInfo, TYPEATTR>::typeinfo_attr_base< &ITypeInfo::ReleaseTypeAttr > type_attr_t;
/// Auto-release wrapper for FUNCDESC.
typedef impl::tlib_info<ITypeInfo, FUNCDESC>::typeinfo_attr_base< &ITypeInfo::ReleaseFuncDesc > func_desc_t;
/// Auto-release wrapper for VARDESC.
typedef impl::tlib_info<ITypeInfo, VARDESC>::typeinfo_attr_base< &ITypeInfo::ReleaseVarDesc > var_desc_t;
/// Auto-release wrapper for TLIBATTR.
typedef impl::tlib_info<ITypeLib, TLIBATTR>::typeinfo_attr_base< &ITypeLib::ReleaseTLibAttr > tlibattr_t;
/** Flags for GetImplTypeFlags.
* \sa IMPLTYPEFLAGS
*/
enum impl_type_flag
{
eft_default=0x1, ///< The interface or dispinterface represents the default for the source or sink.
eft_source =0x2, ///< This member of a coclass is called rather than implemented.
eft_restricted=0x4, ///< The member should not be displayed or programmable by users.
eft_defaultvtable=0x8 ///< Sinks receive events through the VTBL.
};
/** Specialisation wrapper for ITypeInfo.
* \struct wrap_t<ITypeInfo> tlbinfo.h comet/tlbinfo.h
* Wrapper for ITypeInfo typelib information.
* \sa ITypeInfo
*/
template<>
struct wrap_t<ITypeInfo>
{
private:
inline ITypeInfo *raw_(){ return reinterpret_cast<ITypeInfo *>(this); }
public:
/** Returns a wrapped Type Attributes struct.
* \sa TYPEATTR
*/
type_attr_t GetTypeAttr()
{
TYPEATTR *pTypeAttr;
raw_()->GetTypeAttr( &pTypeAttr) | raise_exception ;
return type_attr_t( raw_(), pTypeAttr);
}
/// Returns an ITypeComp interface.
com_ptr<ITypeComp> GetTypeComp()
{
com_ptr<ITypeComp> ppTComp;
raw_()->GetTypeComp( ppTComp.out()) | raise_exception;
return ppTComp;
}
/** Get the function description struct.
* \sa FUNCDESC
*/
func_desc_t GetFuncDesc( unsigned int index)
{
FUNCDESC *pFuncDesc ;
raw_()->GetFuncDesc(index, &pFuncDesc) | raise_exception ;
return func_desc_t( raw_(), pFuncDesc);
}
/** Get the Variable/Constant/Datamember description.
* \sa VARDESC
*/
var_desc_t GetVarDesc( unsigned int index )
{
VARDESC *pVarDesc;
raw_()->GetVarDesc( index,&pVarDesc) | raise_exception;
return var_desc_t(raw_(), pVarDesc);
}
#ifdef NOT_YET
std::list<std::string> GetNames( MEMBERID memid )
{
/* [local] */ HRESULT GetNames( /* [in] */ MEMBERID memid, /* [length_is][size_is][out] */ BSTR *rgBstrNames,
/* [in] */ UINT cMaxNames, /* [out] */ UINT *pcNames) ;
}
#endif //
/// Retrieves the type description of implemented interface types.
HREFTYPE GetRefTypeOfImplType( unsigned int index)
{
HREFTYPE reftype;
raw_()->GetRefTypeOfImplType(index, &reftype) | raise_exception;
return reftype;
}
/// Retrieves the type description of implemented interface types.
long GetImplTypeFlags( int index)
{
INT implTypeFlags;
raw_()->GetImplTypeFlags( index, &implTypeFlags) |raise_exception;
return implTypeFlags;
}
#ifdef NOT_YET
std::vector<MEMBERID> GetIDsOfNames( const std::vector<bstr_t> &rgsNames);
{
/* [local] */ HRESULT GetIDsOfNames(
/* [size_is][in] */ LPOLESTR *rgszNames,
/* [in] */ UINT cNames,
/* [size_is][out] */ MEMBERID *pMemId) ;
}
/* [local] */ HRESULT Invoke(
/* [in] */ PVOID pvInstance,
/* [in] */ MEMBERID memid,
/* [in] */ WORD wFlags,
/* [out][in] */ DISPPARAMS *pDispParams,
/* [out] */ VARIANT *pVarResult,
/* [out] */ EXCEPINFO *pExcepInfo,
/* [out] */ UINT *puArgErr) ;
#endif // NOT_YET
/// Raw wrapper to make sure comet still works/compiles.
HRESULT GetIDsOfNames( LPOLESTR *rgszNames, UINT cNames,
MEMBERID *pMemId)
{
return raw_()->GetIDsOfNames( rgszNames, cNames, pMemId);
}
/// Raw wrapper to make sure comet still works/compiles.
HRESULT Invoke( PVOID pvInstance, MEMBERID memid, WORD wFlags,
DISPPARAMS *pDispParams, VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
UINT *puArgErr)
{
return raw_()->Invoke( pvInstance, memid, wFlags, pDispParams, pVarResult, pExcepInfo, puArgErr);
}
bool GetIDOfName( const wchar_t *name, MEMBERID *id)
{
wchar_t *ucname = const_cast<wchar_t *>(name);
return SUCCEEDED(raw_()->GetIDsOfNames( &ucname, 1, id));
}
/// Get the documentation for the specified MEMBERID.
void GetDocumentation(MEMBERID memid, bstr_t *name, bstr_t *docString, DWORD *helpcontext, bstr_t *helpfile)
{
raw_()->GetDocumentation(memid, name?name->out():NULL, docString?docString->out():NULL,
helpcontext, helpfile? helpfile->out():NULL) | raise_exception;
}
/** Get the member name for the specified MEMBERID.
* This is a shortcut for GetDocumentation.
*/
bstr_t GetMemberName(MEMBERID memid)
{
bstr_t name;
raw_()->GetDocumentation(memid, name.out(), NULL, NULL, NULL) | raise_exception;
return name;
}
bstr_t GetName()
{
return GetMemberName(-1);
}
#if NOT_YET
/* [local] */ HRESULT GetDllEntry(
/* [in] */ MEMBERID memid,
/* [in] */ INVOKEKIND invKind,
/* [out] */ BSTR *pBstrDllName,
/* [out] */ BSTR *pBstrName,
/* [out] */ WORD *pwOrdinal) ;
#endif // NOT_YET
/** Get the referenced Type information.
*/
com_ptr<ITypeInfo> GetRefTypeInfo( HREFTYPE refType)
{
com_ptr<ITypeInfo> refinfo;
raw_()->GetRefTypeInfo( refType, refinfo.out()) | raise_exception;
return refinfo;
}
#if NOT_YET
/* [local] */ HRESULT AddressOfMember( /* [in] */ MEMBERID memid, /* [in] */ INVOKEKIND invKind,
/* [out] */ PVOID *ppv) ;
/* [local] */ HRESULT CreateInstance( /* [in] */ IUnknown *pUnkOuter, /* [in] */ REFIID riid,
/* [iid_is][out] */ PVOID *ppvObj) ;
HRESULT GetMops( /* [in] */ MEMBERID memid, /* [out] */ BSTR *pBstrMops) ;
#endif // NOT_YET
/** Get the typelib containing this definition.
* \return A pair containing the typelibrary and the index of the type description within the type library.
*/
std::pair< com_ptr<ITypeLib>, UINT > GetContainingTypeLib()
{
std::pair< com_ptr<ITypeLib>, UINT> result;
raw_()->GetContainingTypeLib( result.first.out(), &(result.second) ) | raise_exception;
return result;
}
};
//@}
template<>
struct wrap_t<ITypeInfo2> : wrap_t<ITypeInfo>
{
TYPEKIND GetTypeKind()
{
TYPEKIND tkind;
raw_()->GetTypeKind(&tkind) | raise_exception;
return tkind;
}
private:
inline ITypeInfo2 *raw_(){ return reinterpret_cast<ITypeInfo2 *>(this); }
};
/*! \addtogroup Interfaces
*/
//@{
/// Specialisation to handle TypeLibrary API.
template<>
struct wrap_t<ITypeLib>
{
inline ITypeLib *raw_(){ return reinterpret_cast<ITypeLib *>(this); }
unsigned int GetTypeInfoCount()
{
return raw_()->GetTypeInfoCount();
}
/// Get typeinfo at specified index.
com_ptr<ITypeInfo> GetTypeInfo( UINT index)
{
com_ptr<ITypeInfo> tinfo;
raw_()->GetTypeInfo( index, tinfo.out()) | raise_exception;
return tinfo;
}
/// Get type of information at specified index.
TYPEKIND GetTypeInfoType( UINT index)
{
TYPEKIND retval;
raw_()->GetTypeInfoType( index, &retval) | raise_exception;
return retval;
}
/// Get typeinfo given GUID.
com_ptr<ITypeInfo> GetTypeInfoOfGuid( const uuid_t &guid )
{
com_ptr<ITypeInfo> tinfo;
raw_()->GetTypeInfoOfGuid( guid, tinfo.out()) | raise_exception;
return tinfo;
}
/// Get Raw Typeinfo of guid.
HRESULT GetTypeInfoOfGuid( REFGUID guid, ITypeInfo **ppTinfo)
{
return raw_()->GetTypeInfoOfGuid( guid,ppTinfo);
}
/// Get attributes of the typelibrary.
tlibattr_t GetLibAttr()
{
TLIBATTR *attr;
raw_()->GetLibAttr( &attr) | raise_exception;
return tlibattr_t( raw_(), attr);
}
com_ptr<ITypeComp> GetTypeComp()
{
com_ptr<ITypeComp> typecomp;
raw_()->GetTypeComp( typecomp.out() ) | raise_exception;
return typecomp;
}
void GetDocumentation(int index, bstr_t *name, bstr_t *docString, DWORD *helpcontext, bstr_t *helpfile)
{
raw_()->GetDocumentation(index, name?name->out():NULL, docString?docString->out():NULL,
helpcontext, helpfile? helpfile->out():NULL) | raise_exception;
}
bstr_t GetItemName(int index)
{
bstr_t name;
raw_()->GetDocumentation(index, name.out(), NULL, NULL, NULL) | raise_exception;
return name;
}
bstr_t GetName()
{
return GetItemName(-1);
}
bool IsName( const bstr_t &name, unsigned long hashval )
{
BOOL ret;
raw_()->IsName( name.in(), hashval, &ret) | raise_exception;
return ret!=0;
}
std::pair<com_ptr<ITypeInfo>, MEMBERID> FindName( const bstr_t &name)
{
std::pair<com_ptr<ITypeInfo>, MEMBERID> result;
USHORT tofind = 1;
raw_()->FindName(name.in(), 0, result.first.out(), &result.second, &tofind) | raise_exception;
return result;
}
#ifdef NOT_YET
std::list<std::pair<com_ptr<ITypeInfo>, MEMBERID> >FindName( const bstr_t &name, int max)
{}
[local]
HRESULT FindName(
[in, out] LPOLESTR szNameBuf,
[in] ULONG lHashVal,
[out,size_is(*pcFound),length_is(*pcFound)] ITypeInfo **ppTInfo,
[out,size_is(*pcFound),length_is(*pcFound)] MEMBERID * rgMemId,
[in, out] USHORT * pcFound
);
#endif // LATER
};
/// Load typeinfo from a file.
namespace typeinfo
{
/** Whether to register the typelibrary on load.
* \relates typeinfo::LoadTypeLib
*/
enum regkind_t { reg_default = REGKIND_DEFAULT, reg_register = REGKIND_REGISTER, reg_none = REGKIND_NONE } ;
/// Load typeinfo from a file.
static inline com_ptr<ITypeLib> LoadTypeLib( const bstr_t &filename, regkind_t regkind= reg_default)
{
com_ptr<ITypeLib> tlib;
LoadTypeLibEx(filename.in(), (REGKIND)(regkind), tlib.out()) | raise_exception;
return tlib;
}
}
//@}
} // namespace comet
#endif /* COMET_TLIBINFO_H */