//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) 1992, Microsoft Corporation.
//
//  File:       formtrck.hxx
//
//  Contents:   This file defines facilities for a standard implementation
//              of reference-counted objects, incorporating mechanisms for
//              tracking the usage history of the objects.
//
//  Classes:    ObjectTracker
//
//  History:    6-Apr-92       MikeSe  Created
//              08-Aug-94      DonCl   copied from cinc, and renamed to formtrck.hxx
//
//----------------------------------------------------------------------------

#ifndef __FORMTRCK_HXX__
#define __FORMTRCK_HXX__

#include <windows.h>

//+-------------------------------------------------------------------------
//
//  Class:      ObjectTracker (otr)
//
//  Purpose:    Provides basis for tracking (OLE) objects (aka interface handles)
//
//  History:    6-Apr-92 MikeSe         Created
//
//  Notes:      Access to this class is only indirect, through the macros
//              defined later.
//
//--------------------------------------------------------------------------

class ObjectTracker
{
protected:

                     ObjectTracker ();

# if DBG == 1

                    ~ObjectTracker();
    ULONG            StdAddRef ( void );
    ULONG            StdRelease ( void );
    void             TrackClassName ( char * pszName );
    unsigned long    GetRefCount ( void ) {return _ulRefs;};

private:

    BOOL             IsClassTracking( char * pszName );

    struct TrackLink *  _tl;
    static  BOOL        _TrackAll;

public:
        // dumps information on all outstanding objects
    static void       DumpTrackingInfo ( int fDeleteNode = 0 );
    static void       TrackClass(BOOL, char * pszName );

# endif // DBG == 1

protected:
    unsigned long      _ulRefs;
};


//+-------------------------------------------------------------------------
//
//  The following macros encapsulate use of the above
//
//  INHERIT_TRACKING:
//
//      For any class which implements a Cairo interface, add this macro
//      in the class declaration, eg:
//
//              class CMyFoo: INHERIT_TRACKING, IFoo
//
//      Do not repeat this in any subclass. If both INHERIT_UNWIND and
//      INHERIT_TRACKING are used, the former should appear first.

# define INHERIT_TRACKING       protected ObjectTracker

        // The following declarations are for non-retail builds

# if DBG == 1

//
// DECLARE_STD_REFCOUNTING:
//
//      To make use of standard refcounting code, place the above
//      in the class declaration, in the public method section. This
//      macro defines the AddRef and Release methods for the class.
//

#  define DECLARE_STD_REFCOUNTING                                       \
        STDMETHOD_(ULONG, AddRef) ()                                    \
                {                                                       \
                    return StdAddRef();                                 \
                };                                                      \
        STDMETHOD_(ULONG, Release) ()                                   \
                {                                                       \
                    ULONG ul = StdRelease();                            \
                    if ( ul==0 ) delete this;                           \
                    return ul;                                          \
                };


//
// DECLARE_NON_DELEGATING_REFCOUNTING:
//
//      For 3rd-party extension.
//
//      To make use of non-delegating refcounting code, place the above
//      in the class declaration, in the public method section. This
//      macro defines the AddRef and Release methods for the class.
//

#  define DECLARE_NON_DELEGATING_REFCOUNTING                            \
        STDMETHOD_(ULONG, NonDelegatingAddRef) ()                       \
                {                                                       \
                    return StdAddRef();                                 \
                };                                                      \
        STDMETHOD_(ULONG, NonDelegatingRelease) ()                      \
                {                                                       \
                    ULONG ul = StdRelease();                            \
                    if ( ul==0 ) delete this;                           \
                    return ul;                                          \
                };

//
//  ENLIST_TRACKING(class name)
//
//      Place an invocation of this in each constructor, at any appropriate
//      point (generally immediately before returning from the constructor).
//
//              ENLIST_TRACKING(CMyFoo)
//

#  define ENLIST_TRACKING(cls)  TrackClassName( #cls )

//
// NB:  In a subclass of a class which has INHERIT_TRACKING, do not
//      use INHERIT_TRACKING again. However, do use ENLIST_TRACKING in
//      in the constructor of the derived class, and use TRACK_ADDREF
//      and TRACK_RELEASE if the subclass overrides the AddRef and Release
//      methods.

//
//  TRACK_CLASS(fTrack, pszClassName)
//
//      Use this to add or remove a class in the list of tracked classes.
//      You can turn tracking of all classes on or off by using a NULL
//      pszClassName.  If fTrack is TRUE, the class will be tracked, if FALSE,
//      the class will no longer be tracked.  The default configuration is
//      that all classes are tracked.
//
//      NOTE: this affects only objects created after this macro is executed.
//

#  define TRACK_CLASS(fTrack, cls) \
                      ObjectTracker::TrackClass( fTrack, cls )

//
//  DUMP_TRACKING_INFO()
//
//      Place this anywhere it would be useful to dump out the object
//      tracking database. By default, this is always issued at program
//      termination.
//

#  define DUMP_TRACKING_INFO()        DUMP_TRACKING_INFO_KEEP()
#  define DUMP_TRACKING_INFO_KEEP()   ObjectTracker::DumpTrackingInfo(0)
#  define DUMP_TRACKING_INFO_DELETE() ObjectTracker::DumpTrackingInfo(1)

//      Output from this is controlled by setting the following mask values
//      in OtInfoLevel

#  define DEB_OT_OBJECTS        0x00000001L
        // display object addresses, reference count and name (Default)

#  define DEB_OT_CALLERS        0x80000000L
        // display call history

// In addition, set the following values to cause debug output during
// operation:

#  define DEB_OT_ERRORS         0x00000002L
        // report errors during tracking operations (Default)

#  define DEB_OT_ACTIONS        0x40000000L
        // report each create, addref and release

#  define DEB_OT_DELETE         0x20000000L
        // display call history at object delete

# else // DBG == 0

inline ObjectTracker::ObjectTracker():_ulRefs(1) {};

#  define DECLARE_STD_REFCOUNTING                                       \
        STDMETHOD_(ULONG, AddRef) ()                                    \
                {                                                       \
                    InterlockedIncrement((long*)&_ulRefs);         \
                    return _ulRefs;                                \
                };                                                      \
        STDMETHOD_(ULONG, Release) ()                                   \
                {                                                          \
                    if ( InterlockedDecrement((long*)&_ulRefs) == 0 ) \
                    {                                                      \
                        delete this;                                       \
                        return 0;                                          \
                    }                                                      \
                    else                                                   \
                        return  _ulRefs;                              \
                };

#  define DECLARE_NON_DELEGATING_REFCOUNTING                                \
        STDMETHOD_(ULONG, NonDelegatingAddRef) ()                           \
                {                                                           \
                    InterlockedIncrement((long*)&_ulRefs);                  \
                    return _ulRefs;                                         \
                };                                                          \
        STDMETHOD_(ULONG, NonDelegatingRelease) ()                          \
                {                                                           \
                    if ( InterlockedDecrement((long*)&_ulRefs) == 0 )       \
                    {                                                       \
                        delete this;                                        \
                        return 0;                                           \
                    }                                                       \
                    else                                                    \
                        return  _ulRefs;                                    \
                };

#  define ENLIST_TRACKING(cls)

#  define DUMP_TRACKING_INFO()

#  define TRACK_CLASS(fTrack, cls)

# endif // DBG == 0

#endif  // of ifndef __OTRACK_HXX__