sdObject.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// sdObject.h
//
// This file contains the definition for the following classes.
//
//  sdObjectType
//      This is a wrapper class for sdObjectTypeEnum. 
// 
//  sdObjectMemberIter
//      This is a template class that supports some base functionality for
//      iterating over members of sdObject. The members are sdAttribute objects
//      and sdRelationshipBase objects.
// 
//  sdObjectAttributeIter
//      This class is the iterator over sdAttributes of an sdObject and supports 
//      iterating over attributes hierarchically.
//
//  sdObjectRelationshipIter
//      This class is the iterator over sdRelationshipBase objects of an 
//      sdObject and supports iterating over relationships hierarchically.
//
//  sdObject
//      This class represents the schema data of a class. An object's schema
//      consists of attributes, relationships etc.
//  
// *****************************************************************************
// 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: icftcm $
//  $Revision: #1 $
//  $Date: 2007/03/20 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(sdObject_P)
#define sdObject_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include <vector>
#include "sdBase.h"



// *****************************************************************************
// Declare and define types in the schema definition namespace.
// *****************************************************************************
BEGIN_SD_NAMESPACE



// *****************************************************************************
// Forward Public Class Declarations
// *****************************************************************************
class sdObject;
class sdAttribute;
class sdRelationshipBase;



// *****************************************************************************
// sdObjectMemberIter
// *****************************************************************************
template<class SDClass>
class sdObjectMemberIter {
public:
    const SDClass                                   *operator*() const;
    bool                                            operator==(const sdObjectMemberIter<SDClass> &iter) const;
    bool                                            operator!=(const sdObjectMemberIter<SDClass> &iter) const;

    sdObjectMemberIter<SDClass>                     &operator++();

protected:
                                                    sdObjectMemberIter();
    virtual                                         ~sdObjectMemberIter();

    typedef std::vector<const SDClass*>             MemberVector;
    typedef typename MemberVector::const_iterator   MemberConstIter;

    MemberVector                                    m_vector;
    MemberConstIter                                 m_iter;
    bool                                            m_isEmpty;
};



// *****************************************************************************
// sdObjectAttributeIter
// *****************************************************************************
class SD_DLL_API sdObjectAttributeIter : public sdObjectMemberIter<sdAttribute> {
public:         
                            sdObjectAttributeIter();
                            sdObjectAttributeIter(const sdObject    *object,
                                                  bool              local);
    virtual                 ~sdObjectAttributeIter();

private:
    void                    traverseHier(const sdObject *current,
                                         MemberVector   &objects);
};



// *****************************************************************************
// sdObjectRelationshipIter
// *****************************************************************************
class SD_DLL_API sdObjectRelationshipIter : public sdObjectMemberIter<sdRelationshipBase> {
public:         
                            sdObjectRelationshipIter();
                            sdObjectRelationshipIter(const sdObject *object,
                                                     bool           local);
    virtual                 ~sdObjectRelationshipIter();

private:
    void                    traverseHier(const sdObject *current,
                                         MemberVector   &objects);
};



// *****************************************************************************
// sdObject
// *****************************************************************************
class SD_DLL_API sdObject : public sdBase {
public:         
    typedef std::vector<const sdObject*>            ObjectVector;
    typedef ObjectVector::const_iterator            ObjectConstIter;

                                                    sdObject(unsigned int       id,
                                                             const std::string  &name,
                                                             const std::string  &description,
                                                             bool               concrete,
                                                             sdNameSpace        *nameSpace,
                                                             const ObjectVector &superObjects);
    virtual                                         ~sdObject();

    unsigned int                                    getId() const;
    const std::string                               &getName() const;
    const std::string                               &getDescription() const;
    bool                                            isConcrete() const;
    const sdAttribute                               *getIdentifier() const;
    ObjectConstIter                                 beginSuperObject() const;
    ObjectConstIter                                 endSuperObject() const;
    ObjectConstIter                                 beginSubObject() const;
    ObjectConstIter                                 endSubObject() const;
    sdObjectAttributeIter                           beginAttribute(bool local) const;
    sdObjectAttributeIter                           endAttribute(bool local) const;

    sdObjectRelationshipIter                        beginRelationship(bool local) const;
    sdObjectRelationshipIter                        endRelationship(bool local) const;

    virtual void                                    accept(sdVisitor *visitor);

private:
    void                                            addAttribute(sdAttribute *attribute);
    void                                            addRelationship(sdRelationshipBase *relationship);
    void                                            setIdentifier(sdAttribute *attribute);
    void                                            addSubObject(sdObject *subObject);
    void                                            removeSubObject(const sdObject *subObject);

    typedef std::vector<const sdAttribute*>         AttributeVector;
    typedef std::vector<const sdRelationshipBase*>  RelationshipVector;

    const unsigned int                              m_id;
    const std::string                               &m_name;
    const std::string                               m_description;
    const bool                                      m_isConcrete;
    AttributeVector                                 m_attributes;
    RelationshipVector                              m_relationships;
    const ObjectVector                              m_superObjects;
    ObjectVector                                    m_subObjects;
    sdAttribute                                     *m_identifier;

    friend class sdAttribute;
    friend class sdRelationship;
    friend class sdRelationshipSet;
    friend class sdObjectAttributeIter;
    friend class sdObjectRelationshipIter;
    friend class sdNameSpace;
};



END_SD_NAMESPACE

#endif

Return to top of page

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