oaObserver.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// oaObserver.h
//
// This file contains the definition for the oaBaseObserver class. This is an
// abstract class used as the base for all types of observers in OpenAccess.
// Capabilities it supports includes:
//
//  1)  Observers can be enabled or disabled as desired. Disabled observers are
//      not called.
//  2)  Observers are ordered by priority. Observers with higher priority (i.e.
//      lower priority numbers) are called first.
//
//  oaBaseObserver
//      This is the base class for the following template classes which support
//      observer signatures for OpenAccess.
//
//  oaStdObserver<>
//      This class, in turn, is the base class for the oaVersionedObserver<>
//      template class definition and several specializations of
//      oaVersionedObserver<>. This class covers the postCreate, preDestroy,
//      preModify, and postModify signatures.
//
//  oaVersionedObserver<T, rev>
//      This class supports the multiple versions of observer signatures which
//      have been added. Applications can instantiate one of the following two
//      revisions which select appropriate observer version. Version 1
//      corresponds to the oaStdObserver<> signatures and is the current default.
//      Version 2 adds the scoped notification signatures onBeginCreate,
//      onEndCreate, onBeginDestroy, and onEndDestory. Selection of the
//      revision should be done using oaRevisionTraits<T>.
//
//
// *****************************************************************************
// Except as specified in the OpenAccess terms of use of Cadence or Silicon
// Integration Initiative, this material may not be copied, modified,
// re-published, uploaded, executed, or distributed in any way, in any medium,
// in whole or in part, without prior written permission from Cadence.
//
//                Copyright 2002-2008 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: dell $
//  $Revision: #9 $
//  $Date: 2008/05/30 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(oaObserver_P)
#define oaObserver_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include "oaBaseTypes.h"
#include "oaRevisionTraits.h"
#include "oaObject.h"


// *****************************************************************************
// Declare and define types in the OpenAccess namespace.
// *****************************************************************************
BEGIN_OA_NAMESPACE



// *****************************************************************************
// oaBaseObserver
// *****************************************************************************
class OA_BASE_DLL_API oaBaseObserver {
public:
                            oaBaseObserver(oaUInt4      priorityIn,
                                           oaBoolean    enabledIn = true);
    virtual                 ~oaBaseObserver();

    oaBoolean               isEnabled() const;

    void                    enable(oaBoolean enabledIn);

protected:
    oaBoolean               enabled;
    oaUInt4                 priority;
};



// *****************************************************************************
// oaStdObserver<>
// *****************************************************************************
template <class T, typename D>
class oaStdObserver : public oaBaseObserver {
public:
                                oaStdObserver(oaUInt4   priorityIn,
                                              oaBoolean enabledIn =     true);
    virtual                     ~oaStdObserver();

    virtual void                onPostCreate(T *object);
    virtual void                onPreDestroy(T *object);
    virtual void                onPreModify(T   *object,
                                            D   modType);
    virtual void                onPostModify(T  *object,
                                             D  modType);

    static oaBoolean            hasObservers();
    static void                 notifyPostCreateObservers(T *object);
    static void                 notifyPreDestroyObservers(T *object);
    static void                 notifyPreModifyObservers(T  *object,
                                                         D  modType);
    static void                 notifyPostModifyObservers(T *object,
                                                          D modType);

protected:
    oaStdObserver<T, D>         *next;

    static oaStdObserver<T, D>  *first;
};



// *****************************************************************************
// oaObserver
// *****************************************************************************
#if !defined(oaObserver)
#define oaObserver oaVersionedObserver
#endif


// *****************************************************************************
// oaVersionedObserver
// *****************************************************************************
template <class T, oaUInt4 rev = (oaUInt4) oaRevisionTraits<T>::observerRevision>
class oaVersionedObserver : public oaStdObserver<T, typename oaTraits<T>::modTypeType> {
public:
                            oaVersionedObserver(oaUInt4     priorityIn,
                                                oaBoolean   enabledIn = true);
};
// <JR> Adding correct class name per Dell "oaVersionedObserver<T, V>"
template <class T>
class oaVersionedObserver<T, V> : public oaStdObserver<T, typename oaTraits<T>::modTypeType> {
public:
                                        oaVersionedObserver(oaUInt4     priorityIn,
                                                            oaBoolean   enabledIn =     true);
    virtual                             ~oaVersionedObserver();

    virtual void                        onBeginCreate(oaObject  *owner,
                                                      oaUInt4   scopeID);
    virtual void                        onEndCreate(T       *object,
                                                    oaUInt4 scopeID);
    virtual void                        onBeginDestroy(T        *object,
                                                       oaUInt4  scopeID);
    virtual void                        onEndDestroy(oaObject   *owner,
                                                     oaUInt4    scopeID);

    static oaBoolean                    hasObservers();

/* <JR> Not needed
    static void                         notifyPreModifyObservers(T                                  *object,
                                                                 typename oaTraits<T>::modTypeType  modType);
    static void                         notifyPostModifyObservers(T                                 *object,
                                                                  typename oaTraits<T>::modTypeType modType);
    static void                         notifyBeginCreateObservers(oaObject *owner,
                                                                   oaUInt4  scopeID);
    static void                         notifyEndCreateObservers(T          *object,
                                                                 oaUInt4    scopeID);
    static void                         notifyBeginDestroyObservers(T       *object,
                                                                    oaUInt4 scopeID);
    static void                         notifyEndDestroyObservers(oaObject  *owner,
                                                                  oaUInt4   scopeID);
*/

protected:
    oaVersionedObserver<T, oacObserverVersion2>         *next;

    static oaVersionedObserver<T, oacObserverVersion2>  *first;
};



END_OA_NAMESPACE

#endif

Return to top of page

Copyright © 2002 - 2010 Cadence Design Systems, Inc.
All Rights Reserved.