srBase.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// srBase.h
//
// This file contains the definition of the schema representation classes.
//
// srBase
//      The base class for the schema representation classes. It defines the
//      interfaces necessary for all schema representation classes.
//
// srValueBase
//      The srValue base class. The application will derive from this base class
//      for each value defined in the application's sdNameSpace. The values are
//      referenced by the attributes.
//
// srAttributeBase
//      The srAttribute base class. The application will derive from this base
//      class for each attribute value defined in the application's sdNameSpace.
//
// srRelationshipBase
//      The srRelationship base class. There are 2 specialized representation
//      to handle 1 to 1 relationship and 1 to N relationship.
//
// srObjectRef
//      srObjectRef encapsulates the definition and representation to an opaque
//      object pointer.
//
// srObjectState
//      srObjectState contains the complete state of a specific object defined
//      in the schema definition, including all the attributes and relationships
//      of the object.
//
// sr1to1Relationship
//      sr1to1Relationship captures a specific 1 to 1 relationship of the
//      application. The relationship uses srObjectRef to store the references
//      to the specific objects in the 1 to 1 relationship.
//
// sr1toNRelationship
//      sr1toNRelationship captures a specific 1 to N relationship of the
//      application. The relationship uses srObjectRef to store the references
//      to the specific objects in the 1 to N relationship.
//
// *****************************************************************************
// 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: jaideep $
//  $Revision: 1.3 $
//  $Date: 2007/03/09 16:31:27 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(srBase_P)
#define srBase_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include <vector>
#include <map>
#include <string>
#include "oaCommonIntrusivePtr.h"
#include "sdValue.h"
#include "sdAttribute.h"
#include "sdRelationship.h"
#include "sdObject.h"
#include "srBaseTypes.h"



// *****************************************************************************
// Declare and define types in the Schema namespace.
// *****************************************************************************
BEGIN_SR_NAMESPACE



// *****************************************************************************
// Forward Public Class Declarations
// *****************************************************************************
class srVisitorMgr;



// *****************************************************************************
// srBase
// *****************************************************************************
class SR_DLL_API srBase {
public:
    typedef srBase          *SPtr;

                            srBase();
    virtual                 ~srBase();

    virtual void            accept(srVisitorMgr &visitor) = 0;

    void                    addRef() const;
    void                    release() const;

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

    mutable unsigned int    m_refCount;
};



// *****************************************************************************
// srValueBase
// *****************************************************************************
class SR_DLL_API srValueBase : public srBase {
public:
    typedef srValueBase     *SPtr;

                            srValueBase(const sd::sdValue *def);
    virtual                 ~srValueBase();

    const sd::sdValue       *getDef() const;

protected:
    void                    *m_data;

private:
                            srValueBase(const srValueBase &copy);
    srValueBase             &operator=(const srValueBase &rhs);
};



// *****************************************************************************
// srObjectRef
// *****************************************************************************
class SR_DLL_API srObjectRef : public srBase {
public:
    typedef srObjectRef         *SPtr;
    typedef const srObjectRef   *CSPtr;

                                srObjectRef(const sd::sdObject  *def,
                                            void                *object);
    virtual                     ~srObjectRef();

    virtual void                accept(srVisitorMgr &visitor);

    const sd::sdObject          *getDef() const;
    void                        *getObject() const;

    void                        setObject(void *object);

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

    void                        *m_data;
};






// *****************************************************************************
// srRelationshipBase
// *****************************************************************************
class SR_DLL_API srRelationshipBase : public srBase {
public:
    typedef srRelationshipBase      *SPtr;

    virtual                         ~srRelationshipBase();

    const sd::sdRelationshipBase    *getDef() const;

    sr::srObjectRef::CSPtr          getFrom() const;

protected:
                                    srRelationshipBase(const sd::sdRelationshipBase *def=0,
                                                       const srObjectRef::CSPtr     from=0);

    void                            *m_data;

private:
                                    srRelationshipBase(const srRelationshipBase &copy);
    srRelationshipBase              &operator=(const srRelationshipBase &rhs);
};



// *****************************************************************************
// srAttributeBase
// *****************************************************************************
class SR_DLL_API srAttributeBase : public srBase {
public:
    typedef srAttributeBase *SPtr;

                            srAttributeBase(const sd::sdAttribute   *def,
                                            const srObjectRef::SPtr object);
    virtual                 ~srAttributeBase();

    srObjectRef::CSPtr      getObject() const;
    const sd::sdAttribute   *getDef() const;

protected:
    void                    *m_data;

private:
                            srAttributeBase(const srAttributeBase &copy);
    srAttributeBase         &operator=(const srAttributeBase &rhs);
};



// *****************************************************************************
// sr1to1Relationship
// *****************************************************************************
class SR_DLL_API sr1to1Relationship : public srRelationshipBase {
public:
    typedef sr1to1Relationship  *SPtr;

                                sr1to1Relationship(const sd::sdRelationshipBase *def,
                                                   const srObjectRef::SPtr      from,
                                                   const srObjectRef::SPtr      to);
    virtual                     ~sr1to1Relationship();

    virtual void                accept(srVisitorMgr &visitor);

    srObjectRef::CSPtr          getTo() const;

    void                        setTo(const srObjectRef::SPtr object);

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

    void                        *m_data;
};



// *****************************************************************************
// sr1toNRelationship
// *****************************************************************************
class SR_DLL_API sr1toNRelationship : public srRelationshipBase {
public:
    typedef sr1toNRelationship              *SPtr;
    typedef std::vector<srObjectRef::SPtr>  ObjectRefVec;
    typedef ObjectRefVec::const_iterator    ConstIterator;

                                            sr1toNRelationship(const sd::sdRelationshipBase *def,
                                                               const srObjectRef::SPtr      from,
                                                               const ObjectRefVec           &to);
    virtual                                 ~sr1toNRelationship();

    virtual void                            accept(srVisitorMgr &visitor);

    ConstIterator                           beginToObject() const;
    ConstIterator                           endToObject() const;

    void                                    setTo(const ObjectRefVec &objects);

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

    void                                    *m_data;
};



// *****************************************************************************
// srSDEnumLess
// *****************************************************************************
template<class T>
class srSDEnumLess {
public:
    bool                    operator()(const T  *lhs,
                                       const T  *rhs) const;
};



// *****************************************************************************
// srObjectState
// *****************************************************************************
class SR_DLL_API srObjectState : public srBase {
public:
    typedef srObjectState                                                                                           *SPtr;
    typedef std::map<const sd::sdAttribute*, srAttributeBase::SPtr, srSDEnumLess<sd::sdAttribute> >                  AttributeMap;
    typedef std::map<const sd::sdRelationshipBase*, srRelationshipBase::SPtr, srSDEnumLess<sd::sdRelationshipBase> > RelationshipMap;
    typedef std::pair<const sd::sdAttribute*, srAttributeBase::SPtr>                                                AttributePair;
    typedef std::pair<const sd::sdRelationshipBase*, srRelationshipBase::SPtr>                                      RelationshipPair;

    typedef AttributeMap::const_iterator                                                                            AttributeConstIter;
    typedef RelationshipMap::const_iterator                                                                         RelationshipConstIter;

                                                                                                                    srObjectState(const sd::sdObject    *def,
                                                                                                                                  const AttributeMap    &attributes,
                                                                                                                                  const RelationshipMap &relationships);
    virtual                                                                                                         ~srObjectState();

    virtual void                                                                                                    accept(srVisitorMgr &visitor);

    const sd::sdObject                                                                                              *getDef() const;
    AttributeConstIter                                                                                              beginAttribute() const;
    AttributeConstIter                                                                                              endAttribute() const;
    RelationshipConstIter                                                                                           beginRelationship() const;
    RelationshipConstIter                                                                                           endRelationship() const;

    void                                                                                                            addAttribute(srAttributeBase::SPtr  attribute,
                                                                                                                                 bool                   overwrite = false);
    void                                                                                                            addRelationship(srRelationshipBase::SPtr    relationship,
                                                                                                                                    bool                        overwrite = false);
    void                                                                                                            setAttributes(const AttributeMap &attributes);
    void                                                                                                            setRelationships(const RelationshipMap &relationships);

private:
    typedef std::pair<AttributeMap::iterator, bool>                                                                 AttributeCheck;
    typedef std::pair<RelationshipMap::iterator, bool>                                                              RelationshipCheck;

                                                                                                                    srObjectState(const srObjectState &copy);
    srObjectState                                                                                                   &operator=(const srObjectState &rhs);

    void                                                                                                            *m_data;
};



END_SR_NAMESPACE

#endif

Return to top of page

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