sdNameSpace.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// sdNameSpace.h
//
// This file contains the definition for the following classes.
//
//  sdNameSpace
//      This is a class that is used to partition the schema into different 
//      groups and revisions. This class holds the schema objects of a
//      particular revision of a software component.
//
// *****************************************************************************
// 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(sdNameSpace_P)
#define sdNameSpace_P



// *****************************************************************************
// Nested includes
// *****************************************************************************
#include <vector>
#include <map>
#include <set>
#include "sdBaseTypes.h"



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



// *****************************************************************************
// Forward Public Class Declarations
// *****************************************************************************
class sdAttribute;
class sdObject;
class sdRelationshipBase;
class sdSession;
class sdValue;
class sdVisitor;


// *****************************************************************************
// sdNameSpace
// *****************************************************************************
class SD_DLL_API sdNameSpace {
public:
    typedef std::map<unsigned int, const sdValue*>                  ValueMap;
    typedef std::map<unsigned int, const sdAttribute*>              AttributeMap;
    typedef std::map<unsigned int, const sdRelationshipBase*>       RelationshipMap;
    typedef std::map<unsigned int, const sdObject*>                 ObjectMap;
    typedef std::vector<std::string>                                StringVector;

    typedef ValueMap::const_iterator                                ValueConstIter;
    typedef AttributeMap::const_iterator                            AttributeConstIter;
    typedef RelationshipMap::const_iterator                         RelationshipConstIter;
    typedef ObjectMap::const_iterator                               ObjectConstIter;
    typedef StringVector::const_iterator                            StringConstIter;

                                                                    sdNameSpace(const std::string   &name,
                                                                                const unsigned int  version);

                                                                    sdNameSpace(const std::string   &name,
                                                                                const unsigned int  &version,
                                                                                const StringVector  &dependencies,
                                                                                const StringVector  &aliases);
    virtual                                                         ~sdNameSpace();

    const sdValue                                                   *findValue(unsigned int enumValue) const;
    const sdValue                                                   *findValue(const std::string &enumName) const;

    const sdAttribute                                               *findAttribute(unsigned int enumValue) const;
    const sdAttribute                                               *findAttribute(const std::string &enumName) const;

    const sdObject                                                  *findObject(unsigned int enumValue) const;
    const sdObject                                                  *findObject(const std::string &enumName) const;

    const sdRelationshipBase                                        *findRelationship(unsigned int enumValue) const;
    const sdRelationshipBase                                        *findRelationship(const std::string &enumName) const;


    const std::string                                               &getName() const;
    unsigned int                                                    getVersion() const;
    bool                                                            dependsOn(const sdNameSpace *nameSpace) const;
    bool                                                            isInitialized() const;

    ValueConstIter                                                  beginValue() const;
    ValueConstIter                                                  endValue() const;
    AttributeConstIter                                              beginAttribute() const;
    AttributeConstIter                                              endAttribute() const;
    RelationshipConstIter                                           beginRelationship() const;
    RelationshipConstIter                                           endRelationship() const;
    ObjectConstIter                                                 beginObject() const;
    ObjectConstIter                                                 endObject() const;
    StringConstIter                                                 beginDependentNameSpace() const;
    StringConstIter                                                 endDependentNameSpace() const;
    StringConstIter                                                 beginNameAlias() const;
    StringConstIter                                                 endNameAlias() const;

    virtual void                                                    accept(sdVisitor *visitor);

protected:
    virtual void                                                    createSDObjects() = 0;
    virtual void                                                    destroySDObjects() = 0;

private:
    const std::string                                               &addString(const std::string &string);
    void                                                            addValue(const sdValue *value);
    void                                                            addAttribute(const sdAttribute *attribute);
    void                                                            addRelationship(const sdRelationshipBase *relationship);
    void                                                            addObject(const sdObject *object);


    void                                                            removeInterObjectDependencies();
    void                                                            clear();

    typedef std::set<std::string>                                   StringSet;
    typedef std::map<const std::string*, const sdValue*>            ValueNameMap;
    typedef std::map<const std::string*, const sdObject*>           ObjectNameMap;

    typedef std::map<const std::string*, const sdAttribute*>        AttributeNameMap;
    typedef std::map<const std::string*, const sdRelationshipBase*> RelationshipNameMap;

    ValueMap                                                        m_valueIdMap;
    AttributeMap                                                    m_attributeIdMap;
    RelationshipMap                                                 m_relationshipIdMap;
    ObjectMap                                                       m_objectIdMap;
    StringVector                                                    m_dependencies;
    StringVector                                                    m_aliases;
    const std::string                                               m_name;
    unsigned int                                                    m_version;
    StringSet                                                       m_strings;
    ValueNameMap                                                    m_valueNameMap;
    AttributeNameMap                                                m_attributeNameMap;
    RelationshipNameMap                                             m_relationshipNameMap;
    ObjectNameMap                                                   m_objectNameMap;

    friend class sdValue;
    friend class sdAttribute;
    friend class sdObject;
    friend class sdRelationshipBase;
    friend class sdField;
    friend class sdSession;
};



END_SD_NAMESPACE

#endif

Return to top of page

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