#ifndef _HXX_CARY
#define _HXX_CARY
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1993.
//
// File: formsary.hxx
//
// Contents: CADsAry* classes
//
// Classes: CBaseEnum
// CEnumGeneric
// CEnumVARIANT
// CADsAry
//
// Functions: (none)
//
// History: 12-29-93 adams Created
// 1-12-94 adams Renamed from cary.hxx to formsary.hxx
//
//----------------------------------------------------------------------------
#include <noutil.hxx>
class CADsAry;
//+------------------------------------------------------------------------
//
// Macro that calculates the number of elements in a statically-defined
// array.
//
//-------------------------------------------------------------------------
#define ARRAY_SIZE(_a) (sizeof(_a) / sizeof(_a[0]))
//+---------------------------------------------------------------------------
//
// Class: CBaseEnum (benum)
//
// Purpose: Base OLE enumerator class for a CADsAry.
//
// Interface: DECLARE_ADs_STANRARD_IUNKNOWN
//
// Next -- Per IEnum*
// Skip -- ""
// Reset -- ""
// Clone -- ""
// CBaseEnum -- ctor.
// CBaseEnum -- ctor.
// ~CBaseEnum -- dtor.
// Init -- 2nd stage initialization.
// Deref -- gets pointer to element.
//
// History: 5-15-94 adams Created
//
// Notes: Since there is no IEnum interface, we create a vtable
// with the same layout as all IEnum interfaces. Be careful
// where you put virtual function declarations!
//
//----------------------------------------------------------------------------
class CBaseEnum : public IUnknown
{
public:
DECLARE_ADs_STANDARD_IUNKNOWN(CBaseEnum);
// IEnum methods
STDMETHOD(Next) (ULONG celt, void * reelt, ULONG * pceltFetched) PURE;
STDMETHOD(Skip) (ULONG celt);
STDMETHOD(Reset) (void);
STDMETHOD(Clone) (CBaseEnum ** ppenum) PURE;
//
// Ensure that vtable contains virtual destructor after other virtual methods.
//
virtual ~CBaseEnum(void);
protected:
CBaseEnum(size_t cb, REFIID iid, BOOL fAddRef, BOOL fDelete);
CBaseEnum(const CBaseEnum & benum);
CBaseEnum& operator=(const CBaseEnum & benum); // don't define
HRESULT Init(CADsAry * pary, BOOL fCopy);
void * Deref(int i);
CADsAry * _pary;
const IID * _piid;
int _i;
size_t _cb;
BOOL _fAddRef;
BOOL _fDelete;
};
//+---------------------------------------------------------------------------
//
// Class: CEnumGeneric (enumg)
//
// Purpose: OLE enumerator for class CADsAry.
//
// Interface: Next -- Per IEnum
// Clone -- ""
// Create -- Creates a new enumerator.
// CEnumGeneric -- ctor.
// CEnumGeneric -- ctor.
//
// History: 5-15-94 adams Created
//
//----------------------------------------------------------------------------
class CEnumGeneric : public CBaseEnum
{
public:
// IEnum methods
STDMETHOD(Next) (ULONG celt, void * reelt, ULONG * pceltFetched);
STDMETHOD(Clone) (CBaseEnum ** ppenum);
// CEnumGeneric methods
static HRESULT Create(
size_t cb,
CADsAry * pary,
REFIID iid,
BOOL fAddRef,
BOOL fCopy,
BOOL fDelete,
CEnumGeneric ** ppenum);
protected:
CEnumGeneric(size_t cb, REFIID iid, BOOL fAddRef, BOOL fDelete);
CEnumGeneric(const CEnumGeneric & enumg);
CEnumGeneric& operator=(const CEnumGeneric & enumg); // don't define
};
//+---------------------------------------------------------------------------
//
// Class: CEnumVARIANT (enumv)
//
// Purpose: OLE enumerator for class CADsAry.
//
// Interface: Next -- Per IEnum
// Clone -- ""
// Create -- Creates a new enumerator.
// CEnumGeneric -- ctor.
// CEnumGeneric -- ctor.
//
// History: 5-15-94 adams Created
//
//----------------------------------------------------------------------------
class CEnumVARIANT : public CBaseEnum
{
public:
// IEnum methods
STDMETHOD(Next) (ULONG celt, void * reelt, ULONG * pceltFetched);
STDMETHOD(Clone) (CBaseEnum ** ppenum);
static HRESULT Create(
size_t cb,
CADsAry * pary,
VARTYPE vt,
BOOL fCopy,
BOOL fDelete,
IEnumVARIANT ** ppenum);
protected:
CEnumVARIANT(size_t cb, VARTYPE vt, BOOL fDelete);
CEnumVARIANT(const CEnumVARIANT & enumv);
// don't define
CEnumVARIANT& operator =(const CEnumVARIANT & enumv);
VARTYPE _vt; // type of element enumerated
};
//+------------------------------------------------------------------------
//
// Class: CADsAry (ary)
//
// Purpose: Generic resizeable array class. Note that most of
// the functionality in this class is provided in
// protected members. The DECLARE_ADsPTRARY and
// DECLARE_ADsDATAARY macros define concrete implementations
// of the array class. In these concrete classes, public
// methods are provided which delegate to the protected
// methods. This allows us to avoid storing the element
// size with the array.
//
// Interface:
// CADsAry, ~CADsAry
//
// EnsureSize Ensures that the array is at least a certain
// size, allocating more memory if necessary.
// Note that the array size is measured in elements,
// rather than in bytes.
// Size Returns the current size of the array.
// SetSize Sets the array size; EnsureSize must be called
// first to reserve space if the array is growing
//
// operator LPVOID Allow the CADsAry class to be cast
// to a (void *)
//
// Append Adds a new pointer to the end of the array,
// growing the array if necessary. Only works
// for arrays of pointers.
// AppendIndirect As Append, for non-pointer arrays
//
// Insert Inserts a new pointer at the given index in
// the array, growing the array if necessary. Any
// elements at or following the index are moved
// out of the way.
// InsertIndirect As Insert, for non-pointer arrays
//
// Delete Deletes an element of the array, moving any
// elements that follow it to fill
// DeleteMultiple Deletes a range of elements from the array,
// moving to fill
// BringToFront Moves an element of the array to index 0,
// shuffling elements to make room
// SendToBack Moves an element to the end of the array,
// shuffling elements to make room
//
// Find Returns the index at which a given pointer
// is found
// FindIndirect As Find, for non-pointer arrays
//
// Copy Creates a copy of the object.
//
// EnumElements Create an enumerator which supports the given
// interface ID for the contents of the array
//
// EnumElements Create an IEnumVARIANT enumerator.
//
//
// Deref Returns a pointer to an element of the array;
// normally used by type-safe methods in derived
// classes
//
// GetAlloced Get number of elements allocated
//
// Members: _c Current size of the array
// _pv Buffer storing the elements
//
// Note: The CADsAry class only supports arrays of elements
// whose size is less than CADsAry_MAXELEMSIZE (currently 128).
//
//-------------------------------------------------------------------------
class CADsAry
{
friend CBaseEnum;
friend CEnumGeneric;
friend CEnumVARIANT;
public:
CADsAry(void)
{ _c = 0; _pv = NULL; }
~CADsAry();
int Size(void)
{ return _c; }
void SetSize(int c)
{ _c = c;}
operator LPVOID(void)
{ return _pv; }
void DeleteAll(void);
protected:
// Methods which are wrapped by inline subclass methods
HRESULT EnsureSize(size_t cb, int c);
HRESULT AppendIndirect(size_t cb, void * pv);
HRESULT InsertIndirect(size_t cb, int i, void * pv);
int FindIndirect(size_t cb, void **);
void Delete(size_t cb, int i);
void BringToFront(size_t cb, int i);
void SendToBack(size_t cb, int i);
HRESULT Copy(size_t cb, const CADsAry& ary, BOOL fAddRef);
int GetAlloced(size_t cb)
{ return _pv ? LocalSize(_pv) / cb : 0; }
HRESULT EnumElements(
size_t cb,
REFIID iid,
void ** ppv,
BOOL fAddRef,
BOOL fCopy = TRUE,
BOOL fDelete = TRUE);
HRESULT EnumVARIANT(
size_t cb,
VARTYPE vt,
IEnumVARIANT ** ppenum,
BOOL fCopy = TRUE,
BOOL fDelete = TRUE);
// Internal helpers
void * Deref(size_t cb, int i);
int _c;
void * _pv;
NO_COPY(CADsAry);
};
#define CADsAry_MAXELEMSIZE 128
//+---------------------------------------------------------------------------
//
// Member: CBaseEnum::Deref
//
// Synopsis: Forwards deref to _pary. Required because classes derived
// from CBaseEnum are friends of CADsAry.
//
// History: 5-15-94 adams Created
//
//----------------------------------------------------------------------------
inline void *
CBaseEnum::Deref(int i)
{
// KrishnaG: commented this out while porting, MUSTRESOLVE
//Assert(i >= 0);
return ((BYTE *) _pary->_pv) + i * _cb;
}
//+------------------------------------------------------------------------
//
// Class: CADsPtrAry (ary)
//
// Purpose: Subclass used for arrays of pointers. In this case, the
// element size is known. Normally, the DECLARE_ADsPTRARY
// macro is used to define a specific concrete implementation
// of this class, to hold a specific type of pointer.
//
//-------------------------------------------------------------------------
class CADsPtrAry : public CADsAry
{
public:
CADsPtrAry(void) : CADsAry( ) { ; }
HRESULT EnsureSize(int c);
HRESULT Append(void * pv);
HRESULT Insert(int i, void * pv);
int Find(void * pv);
void Delete(int i);
void BringToFront(int i);
void SendToBack(int i);
HRESULT Copy(const CADsAry& ary, BOOL fAddRef);
HRESULT EnumElements(
REFIID iid,
void ** ppv,
BOOL fAddRef,
BOOL fCopy = TRUE,
BOOL fDelete = TRUE);
HRESULT EnumVARIANT(
VARTYPE vt,
IEnumVARIANT ** ppenum,
BOOL fCopy = TRUE,
BOOL fDelete = TRUE);
};
//+------------------------------------------------------------------------
//
// Macro: DECLARE_ADsDATAARY
//
// Purpose: Declares a type-safe class derived from CADsAry.
//
// Arguments: _Cls -- Name of new array class
// _Ty -- Type of array element (e.g. FOO)
// _pTy -- Type which is a pointer to _Ty (e.g. LPFOO)
//
// Interface: operator [] Provides a type-safe pointer to an element
// of the array
// operator LPFOO Allows the array to be cast to a type-safe
// pointer to its first element
//
// In addition, all the protected members introduced by
// the CADsAry class are wrapped with public inlines
// which substitute the known element size for this
// array type.
//
//-------------------------------------------------------------------------
#define DECLARE_ADsDATAARY(_Cls, _Ty, _pTy) \
class _Cls : public CADsAry \
{ \
public: \
_Cls(void) : CADsAry() { ; } \
_Ty& operator[] (int i) { return * (_pTy) Deref(sizeof(_Ty), i); } \
operator _pTy(void) { return (_pTy) _pv; } \
_Cls(const _Cls &); \
_Cls& operator=(const _Cls &); \
\
HRESULT EnsureSize(int c) \
{ return CADsAry::EnsureSize(sizeof(_Ty), c); } \
HRESULT AppendIndirect(void * pv) \
{ return CADsAry::AppendIndirect(sizeof(_Ty), pv); } \
HRESULT InsertIndirect(int i, void * pv) \
{ return CADsAry::InsertIndirect(sizeof(_Ty), i, pv); } \
int FindIndirect(void ** ppv) \
{ return CADsAry::FindIndirect(sizeof(_Ty), ppv); } \
\
void Delete(int i) \
{ CADsAry::Delete(sizeof(_Ty), i); } \
void BringToFront(int i) \
{ CADsAry::BringToFront(sizeof(_Ty), i); } \
void SendToBack(int i) \
{ CADsAry::SendToBack(sizeof(_Ty), i); } \
\
HRESULT Copy(const CADsAry& ary, BOOL fAddRef) \
{ return CADsAry::Copy(sizeof(_Ty), ary, fAddRef); } \
\
HRESULT EnumElements( \
REFIID iid, \
void ** ppv, \
BOOL fAddRef, \
BOOL fCopy = TRUE, \
BOOL fDelete = TRUE) \
{ return CADsAry::EnumElements(sizeof(_Ty), iid, ppv, fAddRef, fCopy, fDelete); } \
\
HRESULT EnumVARIANT( \
VARTYPE vt, \
IEnumVARIANT ** ppenum, \
BOOL fCopy = TRUE, \
BOOL fDelete = TRUE) \
{ return CADsAry::EnumVARIANT(sizeof(_Ty), vt, ppenum, fCopy, fDelete); } \
};
//+------------------------------------------------------------------------
//
// Macro: DECLARE_ADsDATAARY
//
// Purpose: Declares a type-safe class derived from CADsPtrAry.
//
// Arguments: _Cls -- Name of new array class
// _Ty -- Type of array element (e.g. FOO)
// _pTy -- Type which is a pointer to _Ty (e.g. LPFOO)
//
// Interface: operator [] Provides a type-safe pointer to an element
// of the array
// operator LPFOO Allows the array to be cast to a type-safe
// pointer to its first element
//
//-------------------------------------------------------------------------
#define DECLARE_ADsPTRARY(_Cls, _Ty, _pTy) \
class _Cls : public CADsPtrAry \
{ \
public: \
_Cls(void) : CADsPtrAry() { ; } \
_Ty& operator[] (int i) { return * (_pTy) Deref(sizeof(void *), i); } \
operator _pTy(void) { return (_pTy) _pv; } \
_Cls(const _Cls &); \
_Cls& operator=(const _Cls &); \
};
//+------------------------------------------------------------------------
//
// Common CAry classes
//
//-------------------------------------------------------------------------
typedef LPDISPATCH * LPLPDISPATCH;
DECLARE_ADsPTRARY(CAryDisp, LPDISPATCH, LPLPDISPATCH);
#endif // #ifndef _HXX_CARY