|
|
///////////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 1997, Microsoft Corp. All rights reserved.
//
// FILE
//
// iasapix.h
//
// SYNOPSIS
//
// This file describes the IAS C++ API.
//
// MODIFICATION HISTORY
//
// 11/10/1997 Original version.
// 01/08/1998 Renamed to iasapix.h (was iascback.h).
// 08/10/1998 Remove obsolete IASRegMap.
//
///////////////////////////////////////////////////////////////////////////////
#ifndef _IASAPIX_H_
#define _IASAPIX_H_
#ifndef _IASAPI_H_
#error iasapi.h must be included first.
#endif
#ifdef __cplusplus
///////////////////////////////////////////////////////////////////////////////
//
// MACRO
//
// IAS_DECLARE_REGISTRY
//
// DESCRIPTION
//
// Macro that allows ATL COM components to use the IASRegisterComponent
// API.
//
///////////////////////////////////////////////////////////////////////////////
#define IAS_DECLARE_REGISTRY(coclass, ver, flags, tlb) \
static HRESULT WINAPI UpdateRegistry(BOOL bRegister) \{ \ return IASRegisterComponent(_Module.GetModuleInstance(), \ __uuidof(coclass), \ IASProgramName, \ L ## #coclass, \ flags, \ __uuidof(tlb), \ ver, \ 0, \ bRegister); \}
///////////////////////////////////////////////////////////////////////////////
//
// STRUCT
//
// Callback
//
// DESCRIPTION
//
// This servers as the base class for all callback objects. The
// CallbackRoutine member serves as a mini-vtable to provide polymorphism.
// I chose not to use a virtual function for two reasons: C compatibility
// and to make the IAS_CALLBACK struct as lightweight as possible. The
// Callback objects make use of the small block allocator, so all
// derived classes must be smaller than IAS_SMALLBLOCK_SIZE.
//
///////////////////////////////////////////////////////////////////////////////
struct Callback : IAS_CALLBACK{ Callback(VOID (WINAPI *pFn)(Callback*)) { CallbackRoutine = (IAS_CALLBACK_ROUTINE)pFn; }
void operator()(){ CallbackRoutine(this); }};
///////////////////////////////////////////////////////////////////////////////
//
// STRUCT
//
// cback_fun_t, cback_fun1_t, cback_mem_t, cback_mem1_t
//
// DESCRIPTION
//
// Various templated classes that extend Callback to implement the most
// common scenarios.
//
// These classes should not be instantiated directly. Use the MakeCallback
// and MakeBoundCallback functions instead (see below).
//
///////////////////////////////////////////////////////////////////////////////
template <class Fn>struct cback_fun_t : Callback{ typedef cback_fun_t<Fn> _Myt;
cback_fun_t(Fn pFn) : Callback(CallbackRoutine), m_pFn(pFn) { }
void operator()() { m_pFn(); }
protected: Fn m_pFn;
static VOID WINAPI CallbackRoutine(Callback* This) { (*((_Myt*)This))(); delete This; }};
template <class Fn, class A>struct cback_fun1_t : Callback{ typedef cback_fun1_t<Fn, A> _Myt;
cback_fun1_t(Fn pFn, A vArg) : Callback(CallbackRoutine), m_pFn(pFn), m_vArg(vArg) { }
void operator()() { m_pFn(m_vArg); }
protected: Fn m_pFn; A m_vArg;
static VOID WINAPI CallbackRoutine(Callback* This) { (*((_Myt*)This))(); delete This; }};
template <class Ty, class Fn>struct cback_mem_t : Callback{ typedef cback_mem_t<Ty, Fn> _Myt;
cback_mem_t(Ty* pObj, Fn pFn) : Callback(CallbackRoutine), m_pObj(pObj), m_pFn(pFn) { }
void operator()() { (m_pObj->*m_pFn)(); }
protected: Ty* m_pObj; Fn m_pFn;
static VOID WINAPI CallbackRoutine(Callback* This) { (*((_Myt*)This))(); delete This; }};
template <class Ty, class Fn, class A>struct cback_mem1_t : Callback{ typedef cback_mem1_t<Ty, Fn, A> _Myt;
cback_mem1_t(Ty* pObj, Fn pFn, A vArg) : Callback(CallbackRoutine), m_pObj(pObj), m_pFn(pFn), m_vArg(vArg) { }
void operator()() { (m_pObj->*m_pFn)(m_vArg); }
protected: Ty* m_pObj; A m_vArg; // Put m_vArg second since it might require 8 byte alignment.
Fn m_pFn;
static VOID WINAPI CallbackRoutine(Callback* This) { (*((_Myt*)This))(); delete This; }};
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION
//
// MakeCallback
//
// DESCRIPTION
//
// This overloaded function provides an interface for constructing a
// Callback object that invokes a non-member function. The function can
// use any calling convention, have any return type, and take zero or one
// arguments. The argument must have a copy constructor and be eight bytes
// or less.
//
// The callback will be deleted automatically when it is invoked.
// Otherwise, the caller is responsible for deleting the object.
//
// EXAMPLE
//
// class Foo
// {
// public:
// static void Bar(DWORD dwSomeArg);
// };
//
// DWORD dwArg = 12;
// Callback* cback = MakeCallback(&Foo::Bar, dwArg);
//
///////////////////////////////////////////////////////////////////////////////
template <class Fn>inline Callback* MakeCallback(Fn pFn){ return new cback_fun_t<Fn>(pFn);}
template <class Fn, class A>inline Callback* MakeCallback(Fn pFn, A vArg){ return new cback_fun1_t<Fn, A>(pFn, vArg);}
///////////////////////////////////////////////////////////////////////////////
//
// FUNCTION
//
// MakeBoundCallback
//
// DESCRIPTION
//
// This overloaded function provides an interface for constructing a
// Callback object that invokes a bound (member) function. The function
// can use any calling convention, have any return type, and take zero or
// one arguments. The argument must have a copy constructor and be eight
// bytes or less.
//
// The callback will be deleted automatically when it is invoked.
// Otherwise, the caller is responsible for deleting the object.
//
// EXAMPLE
//
// class Foo
// {
// public:
// void Bar(DWORD dwSomeArg);
// } foo;
//
// DWORD dwArg = 12;
// Callback* cback = MakeCallback(&foo, &Foo::Bar, dwArg);
//
///////////////////////////////////////////////////////////////////////////////
template <class Ty, class Fn>inline Callback* MakeBoundCallback(Ty* pObj, Fn pFn){ return new cback_mem_t<Ty, Fn>(pObj, pFn);}
template <class Ty, class Fn, class A>inline Callback* MakeBoundCallback(Ty* pObj, Fn pFn, A vArg){ return new cback_mem1_t<Ty, Fn, A>(pObj, pFn, vArg);}
#endif // __cplusplus
#endif // _IASAPIX_H_
|
