oaCMObject.h

Go to the documentation of this file.

// ****************************************************************************
// ****************************************************************************
// oaCMObject.h
//
// This file contains the definition of the object references and object entry
// classes which are used in the CMS system, as well as their containers and
// visitors.
//
//  oaCMStringEntry
//      This class represents an entry in the string table. Each entry object
//      contains a string.
//
//  oaCMObjectStateEntry
//      This class represents an entry in the object state table. Each entry
//      object contains an object state.
//
//  oaCMStringTbl
//      This class contains string entry objects.
//
//  oaCMObjectStateTbl
//      This class contains object state entry objects.
//
//  oaCMObjectRef
//      This is a object reference which has life-time management
//      functionality.
//
//  oaCMDatabaseRef
//      This is a object reference in which the object is a database.
//
//  oaCMObjectIDRef
//      This is a object reference in which the object can be identified by
//      a single attribute, usually a name.
//
//  oaCMObjectStateRef
//      This is a object reference in which the object can be identified by
//      a state which is a compound --- a collection of attributes and
//      relationships. These objects do not have a single attribute to identify
//      them.
//
//  oaCMObjectVisitor
//      oaCMObject classes supports visitor pattern for various actions on
//      them. This is the interface for the visitor, which is capable of
//      visiting concrete oaCMObject nodes. It can be derived to define
//      specific actions.
//
// ****************************************************************************
// 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 2007 Cadence Design Systems, Inc.
//                           All Rights Reserved.
//
//  $Author: priyav
//  $Revision:
//  $Date: 2007/04/25
//  $State:
// ****************************************************************************
// ****************************************************************************



#if !defined(oaCMObject_P)
#define oaCMObject_P



// ****************************************************************************
// Nested includes
// ****************************************************************************
#include <list>
#include <map>
#include "srBase.h"
#include "srVisitor.h"
#include "oaCMBaseTypes.h"
#include "oaTimeStamp.h"



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



// *****************************************************************************
// Forward Public Class Declarations
// *****************************************************************************
class oaCMObjectRefTbl;
class oaCMDatabaseTbl;
class oaCMStringTbl;
class oaCMObjectStateTbl;
class oaCMDatabaseRef;
class oaChangeSetBase;



// ****************************************************************************
// oaCMStringEntry
// ****************************************************************************
class OA_CM_DLL_API oaCMStringEntry : public sr::srBase {
public:
    typedef oaCMStringEntry *SPtr;

                            oaCMStringEntry(const oaString  &string,
                                            oaCMStringTbl   *tbl,
                                            oaTimeStamp     timeStamp);
    virtual                 ~oaCMStringEntry();

    const char              *getString() const;
    oaTimeStamp             getTimeStamp() const;

    virtual void            accept(sr::srVisitorMgr &visitor);

private:
    oaCMStringTbl           *m_tbl;
    oaString                m_string;
    oaTimeStamp             m_timeStamp;
};



// ****************************************************************************
// oaCMObjectStateEntry
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectStateEntry : public sr::srObjectState {
public:
    typedef oaCMObjectStateEntry    *SPtr;

                                    oaCMObjectStateEntry(const sd::sdObject     *def,
                                                         const AttributeMap     &attributes,
                                                         const RelationshipMap  &relationships,
                                                         oaCMObjectStateTbl     *tbl,
                                                         oaTimeStamp            timeStamp);
    virtual                         ~oaCMObjectStateEntry();

    oaTimeStamp                     getTimeStamp() const;

private:
    oaCMObjectStateTbl              *m_tbl;
    oaTimeStamp                     m_timeStamp;

    friend class oaCMObjectRef;
};



// ****************************************************************************
// oaCMStringTbl
// ****************************************************************************
class OA_CM_DLL_API oaCMStringTbl {
public:
    typedef std::map<std::string, oaCMStringEntry*>::const_iterator StringEntryConstIter;
    typedef std::map<std::string, oaCMStringEntry*>::iterator       StringEntryIter;

                                                                    oaCMStringTbl();
                                                                    ~oaCMStringTbl();

    StringEntryConstIter                                            begin() const;
    StringEntryConstIter                                            end() const;

    oaCMStringEntry::SPtr                                           find(const oaString &str) const;

    void                                                            cleanup(oaTimeStamp timeStamp);

private:
    void                                                            add(oaCMStringEntry *str);
    void                                                            remove(oaCMStringEntry *str);

    std::map<std::string, oaCMStringEntry*>                         m_strings;

    friend class oaCMStringEntry;
};



// ****************************************************************************
// oaCMObjectStateTbl class
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectStateTbl {
public:
    typedef std::list<oaCMObjectStateEntry*>::const_iterator    ObjectStateEntryConstIter;
    typedef std::list<oaCMObjectStateEntry*>::iterator          ObjectStateEntryIter;

                                                                oaCMObjectStateTbl();
                                                                ~oaCMObjectStateTbl();

    ObjectStateEntryConstIter                                   begin() const;
    ObjectStateEntryConstIter                                   end() const;

    void                                                        cleanup(oaTimeStamp timeStamp);

private:
    void                                                        add(oaCMObjectStateEntry *state);
    void                                                        remove(oaCMObjectStateEntry *state);

    std::list<oaCMObjectStateEntry*>                            m_states;

    friend class oaCMObjectStateEntry;
};



// ****************************************************************************
// oaCMObjectRef
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectRef : public sr::srObjectRef {
public:
    typedef oaCMObjectRef   *SPtr;
    typedef oaCMDatabaseRef *DatabaseSPtr;

    virtual void            passivate();
    virtual void            activate();

    virtual DatabaseSPtr    getDatabase() const = 0;

    oaBoolean               isAlive() const;
    oaBoolean               isNew() const;
    oaTimeStamp             getTimeStamp() const;

    void                    setIsNew(oaBoolean isNew);

protected:
                            oaCMObjectRef(const sd::sdObject    *def,
                                          void                  *object,
                                          oaTimeStamp           timeStamp,
                                          oaBoolean             isNew = false);
    virtual                 ~oaCMObjectRef();

private:
                            oaCMObjectRef(const oaCMObjectRef &copy);
    oaCMObjectRef           &operator=(const oaCMObjectRef &rhs);

    oaBoolean               m_alive;
    oaBoolean               m_isNew;
    oaTimeStamp             m_timeStamp;

    friend class oaCMObjectRefTbl;
};



// ****************************************************************************
// oaCMDatabaseRef
// ****************************************************************************
class OA_CM_DLL_API oaCMDatabaseRef : public oaCMObjectRef {
public:
    typedef oaCMDatabaseRef         *SPtr;

                                    oaCMDatabaseRef(const sd::sdObject  *def,
                                                    void                *object,
                                                    oaCMDatabaseTbl     *tbl,
                                                    oaTimeStamp         timeStamp,
                                                    oaBoolean           isNew = false);
    virtual                         ~oaCMDatabaseRef();

    virtual void                    accept(sr::srVisitorMgr &visitor);

    virtual void                    passivate();
    virtual void                    activate();

    virtual oaCMDatabaseRef::SPtr   getDatabase() const;
    oaCMObjectStateEntry::SPtr      getState() const;

    void                            setState(oaCMObjectStateEntry::SPtr state);

private:
                                    oaCMDatabaseRef(const oaCMDatabaseRef &copy);
    oaCMDatabaseRef                 &operator=(const oaCMDatabaseRef &rhs);

    oaCMDatabaseTbl                 *m_tbl;
    oaCMObjectStateEntry::SPtr      m_state;
};



// ****************************************************************************
// oaCMObjectIDRef
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectIDRef : public oaCMObjectRef {
public:
    typedef oaCMObjectIDRef         *SPtr;

                                    oaCMObjectIDRef(const sd::sdObject  *def,
                                                    void                *object,
                                                    oaCMObjectRefTbl    *tbl,
                                                    oaTimeStamp         timeStamp,
                                                    oaBoolean           isNew = false,
                                                    oaCMObjectRef::SPtr scope = NULL);
    virtual                         ~oaCMObjectIDRef();

    virtual void                    accept(sr::srVisitorMgr &visitor);

    virtual void                    passivate();
    virtual void                    activate();

    virtual oaCMDatabaseRef::SPtr   getDatabase() const;
    oaCMObjectRef::SPtr             getScope() const;

    oaCMStringEntry::SPtr           getName() const;
    void                            setName(oaCMStringEntry::SPtr name);

private:
                                    oaCMObjectIDRef(const oaCMObjectIDRef &copy);
    oaCMObjectIDRef                 &operator=(const oaCMObjectIDRef &rhs);

    oaCMObjectRefTbl                *m_tbl;
    oaCMStringEntry::SPtr           m_name;
    oaCMObjectRef::SPtr             m_scope;
};



// ****************************************************************************
// oaCMObjectStateRef
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectStateRef : public oaCMObjectRef {
public:
    typedef oaCMObjectStateRef      *SPtr;

                                    oaCMObjectStateRef(const sd::sdObject   *def,
                                                       void                 *object,
                                                       oaCMObjectRefTbl     *tbl,
                                                       oaTimeStamp          timeStamp,
                                                       oaBoolean            isNew = false,
                                                       oaCMObjectRef::SPtr  scope = NULL);
    virtual                         ~oaCMObjectStateRef();

    virtual void                    accept(sr::srVisitorMgr &visitor);
    virtual void                    passivate();
    virtual void                    activate();

    virtual oaCMDatabaseRef::SPtr   getDatabase() const;
    oaCMObjectRef::SPtr             getScope() const;

    oaCMObjectStateEntry::SPtr      getState() const;
    oaCMObjectStateEntry::SPtr      setState(oaCMObjectStateEntry::SPtr state);

private:
                                    oaCMObjectStateRef(const oaCMObjectStateRef &copy);
    oaCMObjectStateRef              &operator=(const oaCMObjectStateRef &rhs);

    oaCMObjectRefTbl                *m_tbl;
    oaCMObjectStateEntry::SPtr      m_state;
    oaCMObjectRef::SPtr             m_scope;
};



// ****************************************************************************
// oaCMObjectVisitor
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectVisitor : public virtual sr::srVisitor {
public:
    using                   sr::srVisitor::visit;

    virtual                 ~oaCMObjectVisitor();

    virtual void            visit(oaCMObjectIDRef *node) = 0;
    virtual void            visit(oaCMDatabaseRef *node) = 0;
    virtual void            visit(oaCMObjectStateRef *node) = 0;
};



// ****************************************************************************
// oaCMDatabaseTbl
// ****************************************************************************
class OA_CM_DLL_API oaCMDatabaseTbl {
public:
    typedef std::list<oaCMDatabaseRef*>::const_iterator         DatabaseRefConstIter;
    typedef std::list<oaCMDatabaseRef*>::iterator               DatabaseRefIter;

                                                                oaCMDatabaseTbl();
    virtual                                                     ~oaCMDatabaseTbl();

    oaCMDatabaseRef::SPtr                                       find(void *database) const;

    void                                                        onPassivate(oaCMDatabaseRef::SPtr ref);
    void                                                        onActivate(oaCMDatabaseRef::SPtr ref);

    DatabaseRefConstIter                                        begin() const;
    DatabaseRefConstIter                                        end() const;

private:
    void                                                        add(oaCMDatabaseRef *ref);
    void                                                        remove(oaCMDatabaseRef *ref);

    typedef std::map<void*, oaCMDatabaseRef*>::const_iterator   MapConstIter;

    std::map<void*, oaCMDatabaseRef*>                           m_activeDatabases;
    std::list<oaCMDatabaseRef*>                                 m_allDatabases;

    friend class oaCMDatabaseRef;
};



// ****************************************************************************
// oaCMObjectRefTbl
// ****************************************************************************
class OA_CM_DLL_API oaCMObjectRefTbl {
public:
    typedef std::list<oaCMObjectRef*>::const_iterator       ObjectRefConstIter;
    typedef std::list<oaCMObjectRef*>::iterator             ObjectRefIter;

                                                            oaCMObjectRefTbl(oaCMDatabaseRef::SPtr database);
                                                            ~oaCMObjectRefTbl();

    oaCMObjectRef::SPtr                                     find(void *obj) const;

    void                                                    onPassivate(oaCMObjectRef::SPtr ref);
    void                                                    onActivate(oaCMObjectRef::SPtr ref);

    oaCMDatabaseRef::SPtr                                   getDatabase() const;

    ObjectRefConstIter                                      begin() const;
    ObjectRefConstIter                                      end() const;

    void                                                    cleanup(oaTimeStamp timeStamp);

private:
    typedef std::map<void*, oaCMObjectRef*>::const_iterator MapConstIter;

    void                                                    add(oaCMObjectRef *ref);
    void                                                    remove(oaCMObjectRef *ref);

    oaCMDatabaseRef                                         *m_database;
    std::map<void*, oaCMObjectRef*>                         m_activeRefs;
    std::list<oaCMObjectRef*>                               m_allRefs;

    friend class oaCMObjectIDRef;
    friend class oaCMObjectStateRef;
};



END_OA_NAMESPACE

#endif

Return to top of page

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