sdRelationship.h

Go to the documentation of this file.

// *****************************************************************************
// *****************************************************************************
// sdRelationship.h
//
// This file contains the definitions for the following classes.
//
//  sdRelationshipOrderingType
//      This class is a wrapper around sdRelationshipOrderingTypeEnum. The enum
//      values specify whether a relationship is strictly ordered, unordered or
//      optionally ordered.
//
//  sdRelationshipAssociationType
//      This class is a wrapper around sdRelationshipAssociationTypeEnum. The
//      enum values specify whether a relationship is an peer, owned or owner
//      relationship.
//
//  sdRelationshipActionType
//      This class is a wrapper around sdRelationshipActionTypeEnum. The
//      sdRelationshipActionTypeEnum enum defines the various actions that can
//      be performed on a relationship.
//
//  sdRelationshipMultiplicityType 
//      This is a wrapper around sdRelationshipMultiplicityTypeEnum. The enum
//      values specify the multiplicity of the relationship, whether it is one 
//      to one or one to many relationship etc.
// 
//  sdRelationshipSubType 
//      This is a wrapper around sdRelationshipSubTypeEnum. A relationship can
//      be between 2 classes or it can be from 1 class to a set of classes
//      sdRelationshipSubTypeEnum captures the different types of relationships.
//
//  sdRelationshipContainerType
//      This class is a wrapper around the sdRelationshipContainerTypeEnum
//      values. The enum values of sdRelationshipContainerTypeEnum define
//      different ways the related object can be returned.
//
//  sdRelationshipBase
//      This class is a the base class for representing of different types of
//      relationships.
//
//  sdRelationship
//      This is the schema class for representing a relationship between 2 
//      classes.
//
//  sdRelationshipSet
//      This is the schema class for representing a relationship that involves 
//      a single 'from' class and multiple 'to' classes. The 'to' set of
//      classes is a list of valid classes that can have this 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: icftcm $
//  $Revision: #1 $
//  $Date: 2007/03/20 $
//  $State: Exp $
// *****************************************************************************
// *****************************************************************************



#if !defined(sdRelationship_P)
#define sdRelationship_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;



// *****************************************************************************
// sdRelationshipOrderingTypeEnum
// *****************************************************************************
#define sdvNumRelationshipOrderingTypes 3

enum sdRelationshipOrderingTypeEnum {
    sdcUnorderedRelationshipOrderingType            = 0,
    sdcStrictlyOrderedRelationshipOrderingType      = 1,
    sdcOptionallyOrderedRelationshipOrderingType    = 2
};



// *****************************************************************************
// sdRelationshipAssociationTypeEnum
// *****************************************************************************
#define sdvNumRelationshipAssociationTypes 3

enum sdRelationshipAssociationTypeEnum {
    sdcOwnedRelationshipAssociationType = 0,
    sdcOwnerRelationshipAssociationType = 1,
    sdcPeerRelationshipAssociationType  = 2
};



// *****************************************************************************
// sdRelationshipMultiplicityTypeEnum
// *****************************************************************************
#define sdvNumRelationshipMultiplicityTypes 4

enum sdRelationshipMultiplicityTypeEnum {
    sdcOneToOneRelationshipMultiplicityType         = 0,
    sdcOneToZeroOrOneRelationshipMultiplicityType   = 1,
    sdcOneToOneOrManyRelationshipMultiplicityType   = 2,
    sdcOneToZeroOrManyRelationshipMultiplicityType  = 3
};



// *****************************************************************************
// sdRelationshipActionTypeEnum
// *****************************************************************************
#define sdvNumRelationshipActionTypes 4

enum sdRelationshipActionTypeEnum {
    sdcGetRelationshipActionType        = 1,
    sdcCreateRelationshipActionType     = 2,
    sdcDestroyRelationshipActionType    = 4,
    sdcInitRelationshipActionType       = 8
};



// *****************************************************************************
// sdRelationshipSubTypeEnum
// *****************************************************************************
#define sdvNumRelationshipSubTypes 2

enum sdRelationshipSubTypeEnum {
    sdcSingleRelationshipSubType    = 0,
    sdcSetRelationshipSubType       = 1
};



// *****************************************************************************
// sdRelationshipContainerTypeEnum
// *****************************************************************************
#define sdvNumRelationshipContainerTypes 4

enum sdRelationshipContainerTypeEnum {
    sdcSingleRelationshipContainerType      = 0,
    sdcArrayRelationshipContainerType       = 1,
    sdcCollectionRelationshipContainerType  = 2,
    sdc2DTableRelationshipContainerType     = 3
};



// *****************************************************************************
// sdRelationshipOrderingType
// *****************************************************************************
class SD_DLL_API sdRelationshipOrderingType {
public:         
                                    sdRelationshipOrderingType(sdRelationshipOrderingTypeEnum valueType);
                                    sdRelationshipOrderingType(const std::string &name);
                                    ~sdRelationshipOrderingType();

                                    operator                sdRelationshipOrderingTypeEnum() const;
    const std::string               &getName() const;

private:
    static const std::string        *initNames();

    sdRelationshipOrderingTypeEnum  m_value;

    static const std::string        *s_names;
};



// *****************************************************************************
// sdRelationshipAssociationType
// *****************************************************************************
class SD_DLL_API sdRelationshipAssociationType {
public:         
                                        sdRelationshipAssociationType(sdRelationshipAssociationTypeEnum valueType);
                                        sdRelationshipAssociationType(const std::string &name);
                                        ~sdRelationshipAssociationType();

                                        operator                    sdRelationshipAssociationTypeEnum() const;
    const std::string                   &getName() const;

private:
    static const std::string            *initNames();

    sdRelationshipAssociationTypeEnum   m_value;

    static const std::string            *s_names;
};



// *****************************************************************************
// sdRelationshipActionType
// *****************************************************************************
class SD_DLL_API sdRelationshipActionType {
public:
                                    sdRelationshipActionType(sdRelationshipActionTypeEnum valueType);
                                    sdRelationshipActionType(const std::string &name);
                                    ~sdRelationshipActionType();

                                    operator                sdRelationshipActionTypeEnum() const;
    const std::string               &getName() const;

private:
    static const std::string        *initNames();

    sdRelationshipActionTypeEnum    m_value;

    static const std::string        *s_names;
};



// *****************************************************************************
// sdRelationshipMultiplicityType
// *****************************************************************************
class SD_DLL_API sdRelationshipMultiplicityType {
public:         
                                        sdRelationshipMultiplicityType(sdRelationshipMultiplicityTypeEnum valueType);
                                        sdRelationshipMultiplicityType(const std::string &name);
                                        ~sdRelationshipMultiplicityType();

                                        operator                    sdRelationshipMultiplicityTypeEnum() const;
    const std::string                   &getName() const;

private:
    static const std::string            *initNames();

    sdRelationshipMultiplicityTypeEnum  m_value;

    static const std::string            *s_names;
};



// *****************************************************************************
// sdRelationshipSubType
// *****************************************************************************
class SD_DLL_API sdRelationshipSubType {
public:         
                                sdRelationshipSubType(sdRelationshipSubTypeEnum valueType);
                                sdRelationshipSubType(const std::string &name);
                                ~sdRelationshipSubType();

                                operator                    sdRelationshipSubTypeEnum() const;
    const std::string           &getName() const;

private:
    static const std::string    *initNames();

    sdRelationshipSubTypeEnum   m_value;

    static const std::string    *s_names;
};



// *****************************************************************************
// sdRelationshipContainerType
// *****************************************************************************
class SD_DLL_API sdRelationshipContainerType {
public:         
                                    sdRelationshipContainerType(sdRelationshipContainerTypeEnum container);
                                    sdRelationshipContainerType(const std::string &name);
                                    ~sdRelationshipContainerType();

                                    operator                sdRelationshipContainerTypeEnum() const;
    const std::string               &getName() const;

private:
    static const std::string        *initNames();

    sdRelationshipContainerTypeEnum m_value;

    static const std::string        *s_names;
};



// *****************************************************************************
// sdRelationshipBase
// *****************************************************************************
class SD_DLL_API sdRelationshipBase : public sdBase {
public:         
    typedef std::vector<sdRelationshipActionType>   Actions;
    typedef Actions::const_iterator                 ActionConstIter;

    virtual                                         ~sdRelationshipBase();

    unsigned int                                    getId() const;
    const std::string                               &getName() const;
    const std::string                               &getDescription() const;
    sdRelationshipSubType                           getSubType() const;

    sdRelationshipOrderingType                      getOrderType() const;
    sdRelationshipAssociationType                   getAssociationType() const;
    sdRelationshipMultiplicityType                  getMultiplicityType() const;
    sdRelationshipContainerType                     getContainerType() const;

    ActionConstIter                                 begin() const;
    ActionConstIter                                 end() const;

protected:
                                                    sdRelationshipBase(unsigned int                     id,
                                                                       const std::string                &name,
                                                                       const std::string                &relDescription,
                                                                       sdRelationshipOrderingType       orderType,
                                                                       const Actions                    &actions,
                                                                       sdRelationshipAssociationType    associationType,
                                                                       sdRelationshipMultiplicityType   multiplicityType,
                                                                       sdRelationshipContainerType      containerType,
                                                                       sdRelationshipSubType            subType,
                                                                       sdNameSpace                      *nameSpace);

private:
    const unsigned int                              m_id;
    const std::string                               &m_name;
    const std::string                               m_description;
    const Actions                                   m_actions;

    const sdRelationshipAssociationType             m_associationType;
    const sdRelationshipMultiplicityType            m_multiplicityType;

    const sdRelationshipOrderingType                m_orderType;
    const sdRelationshipContainerType               m_containerType;
    const sdRelationshipSubType                     m_subType;
};



// *****************************************************************************
// sdRelationship
// *****************************************************************************
class SD_DLL_API sdRelationship : public sdRelationshipBase {
public:
                            sdRelationship(unsigned int                     id,
                                           const std::string                &name,
                                           const std::string                &relDescription,
                                           sdRelationshipOrderingType       orderType,
                                           const Actions                    &actions,
                                           sdRelationshipAssociationType    associationType,
                                           sdRelationshipMultiplicityType   multiplicityType,
                                           sdRelationshipContainerType      containerType,
                                           sdNameSpace                      *nameSpace,
                                           const sdObject                   *from,
                                           const sdObject                   *to);
    virtual                 ~sdRelationship();

    const sdObject          *getFrom() const;
    const sdObject          *getTo() const;

    virtual void            accept(sdVisitor *visitor);

private:
    const sdObject          *m_from;
    const sdObject          *m_to;
};



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

                                            sdRelationshipSet(unsigned int                      id,
                                                              const std::string                 &name,
                                                              const std::string                 &relDescription,
                                                              sdRelationshipOrderingType        orderType,
                                                              const Actions                     &actions,
                                                              sdRelationshipAssociationType     associationType,
                                                              sdRelationshipMultiplicityType    multiplicityType,
                                                              sdRelationshipContainerType       containerType,
                                                              sdNameSpace                       *nameSpace,
                                                              const sdObject                    *from,
                                                              const ObjectVector                &toObjects);
    virtual                                 ~sdRelationshipSet();

    const sdObject                          *getFrom() const;
    ObjectConstIter                         beginToObject() const;
    ObjectConstIter                         endToObject()  const;

    virtual void                            accept(sdVisitor *visitor);

private:
    const sdObject                          *m_from;
    const ObjectVector                      m_to;
};



END_SD_NAMESPACE

#endif

Return to top of page

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