(file) Return to CIMScope.h CVS log (file) (dir) Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/CIMScope.h between version 1.23 and 1.24

version 1.23, 2006/01/30 16:16:47 version 1.24, 2006/02/17 19:30:37
Line 41 
Line 41 
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 /** /**
     The CIMScope class implements the concept of the scope of a CIM qualifier      The CIMScope class represents the DMTF standard CIM qualifier scope
     object.  The scope of a qualifier defines the set of types of CIM objects      definition.  The scope of a qualifier defines the types of CIM objects
     with which the qualifier may be used.  The possible values are:      with which the qualifier may be used.  A CIMScope contains zero or more
     NONE, CLASS, ASSOCIATION, INDICATION, PROPERTY, REFERENCE, METHOD,      of these values:  CLASS, ASSOCIATION, INDICATION, PROPERTY, REFERENCE,
     PARAMETER, ANY.      METHOD, PARAMETER.
     The scope is a set of one or more of these possible values.  
     The value "NONE" implies a CIMScope object that has not yet been assigned a  
     value (uninitialized).  It is not a valid value for the scope of a  
     qualifier object.  
     The value "ANY" means that the qualifier may be used with any of the CIM  
     object types, and is equivalent to listing each of the object types in the  
     scope.  
 */ */
 class PEGASUS_COMMON_LINKAGE CIMScope class PEGASUS_COMMON_LINKAGE CIMScope
 { {
 public: public:
  
     /** Constructs a CIMScope object with no value set (default constructor).      /**
         The values are null.          Constructs a CIMScope object with the value NONE.
     */     */
     CIMScope ();     CIMScope ();
  
     /** Constructs a CIMScope object from an existing CIMScope object (copy      /**
         constructor).          Constructs a CIMScope object from the value of a specified
         @param   scope   Specifies an instance of CIMScope object.          CIMScope object.
           @param scope The CIMScope object from which to construct a new
               CIMScope object.
     */     */
     CIMScope (const CIMScope & scope);     CIMScope (const CIMScope & scope);
  
     /** Assigns the value of one CIMScope object to another (assignment      /**
         operator).          Assigns the value of the specified CIMScope object to this object.
         @param   scope Specifies the name of a CIMScope object that contains          @param scope The CIMScope object from which to assign this
         the values that you want to assign to another CIMScope object.              CIMScope object.
         @return  The CIMScope object with the values of the specified CIMScope          @return A reference to this CIMScope object.
         object. For example:  
         <pre>  
             CIMScope s0;  
             CIMScope s1(s0);  
         </pre>  
         The values in CIMScope s0 are assigned to the CIMScope s1 instance.  
     */     */
     CIMScope & operator= (const CIMScope & scope);     CIMScope & operator= (const CIMScope & scope);
  
     /** Determines if every value in the specified CIMScope object is included      /**
         in this CIMScope object.          Checks whether the scope contains specified scope values.
         @param   scope - Specifies a name of a CIMScope object.          @param scope A CIMScope specifying the scope values to check.
         @return  True if every value in the specified CIMScope object is          @return True if the scope contains all the values in the specified
                  included in the CIMScope object; otherwise, false.              CIMScope object, false otherwise.
     */     */
     Boolean hasScope (const CIMScope & scope) const;     Boolean hasScope (const CIMScope & scope) const;
  
     /** Adds the specified scope value to the CIMScope object.      /**
         @param   scope - Specifies a scope value. For example:          Adds scopes value to the CIMScope object.
           <p><b>Example:</b>
         <pre>         <pre>
             CIMScope s0;              CIMScope s;
             s0.addScope (CIMScope::INDICATION);              s.addScope(CIMScope::INDICATION);
             if(s0.hasScope (CIMScope::INDICATION))              assert(s.hasScope(CIMScope::INDICATION));
                 ...                             ..  
         </pre>         </pre>
           @param scope A CIMScope containing the scope values to add.
     */     */
     void addScope (const CIMScope & scope);     void addScope (const CIMScope & scope);
  
     /** Compares two CIMScope objects.      /**
         @param  scope - Specifies a CIMScope object.          Compares the CIMScope with a specified CIMScope.
         @return True if the two CIMScope objects are equal; otherwise, false.          @param scope The CIMScope to be compared.
         For example,          @return True if this scope has the same set of values as the
         <pre>              specified scope, false otherwise.
             CIMScope s0;  
             s0.addScope (CIMScope::CLASS + CIMScope::PARAMETER);  
             if(s0.hasScope (CIMScope::CLASS))  
                 ...     ..  
     </pre>  
     */     */
     Boolean equal (const CIMScope & scope) const;     Boolean equal (const CIMScope & scope) const;
  
     /** Combines two CIMScope objects.      /**
         @param  scope - Specifies a CIMScope object to add.          Adds two scope values.
         @return A new CIMScope object that represents the combination of this          <p><b>Example:</b>
                 scope object with the specified scope object.  
         <pre>         <pre>
             CIMScope s0(CIMScope::CLASS);             CIMScope s0(CIMScope::CLASS);
             CIMScope s1(CIMScope::PARAMETER);             CIMScope s1(CIMScope::PARAMETER);
             CIMScope s3 = s0 + S1;             CIMScope s3 = s0 + S1;
         </pre>         </pre>
           @param scope A CIMScope containing the scope value to add to this
               scope.
           @return A new CIMScope object containing a union of the values in the
               two scope objects.
     */     */
     CIMScope operator+ (const CIMScope & scope) const;     CIMScope operator+ (const CIMScope & scope) const;
  
     /** Returns a String representation of the CIMScope object.      /**
           Returns a String representation of the CIMScope object.
         This method is for diagnostic purposes. The format of the output         This method is for diagnostic purposes. The format of the output
         is subject to change.         is subject to change.
           @return A String containing a human-readable representation of the
               scope value.
     */     */
     String toString () const;     String toString () const;
  
     /** Indicates that the CIMScope object has no value (is uninitialized).      /**
           Indicates that the CIMScope object has no value (is uninitialized).
           This is not a valid qualifier scope.
     */     */
     static const CIMScope NONE;     static const CIMScope NONE;
  
     /** Indicates that the qualifier may be used with classes.      /**
           Indicates that the qualifier may be used with classes.
     */     */
     static const CIMScope CLASS;     static const CIMScope CLASS;
  
     /** Indicates that the qualifier may be used with associations.      /**
           Indicates that the qualifier may be used with associations.
     */     */
     static const CIMScope ASSOCIATION;     static const CIMScope ASSOCIATION;
  
     /** Indicates that the qualifier may be used with indications.      /**
           Indicates that the qualifier may be used with indications.
     */     */
     static const CIMScope INDICATION;     static const CIMScope INDICATION;
  
     /** Indicates that the qualifier may be used with properties.      /**
           Indicates that the qualifier may be used with properties.
     */     */
     static const CIMScope PROPERTY;     static const CIMScope PROPERTY;
  
     /** Indicates that the qualifier may be used with references.      /**
           Indicates that the qualifier may be used with references.
     */     */
     static const CIMScope REFERENCE;     static const CIMScope REFERENCE;
  
     /** Indicates that the qualifier may be used with methods.      /**
           Indicates that the qualifier may be used with methods.
     */     */
     static const CIMScope METHOD;     static const CIMScope METHOD;
  
     /** Indicates that the qualifier may be used with parameters.      /**
           Indicates that the qualifier may be used with parameters.
     */     */
     static const CIMScope PARAMETER;     static const CIMScope PARAMETER;
  
     /** Indicates that the qualifier may be used with any of the types      /**
           Indicates that the qualifier may be used with any of the types
         of objects (classes, associations, indications, properties, references,         of objects (classes, associations, indications, properties, references,
         methods, parameters).         methods, parameters).
     */     */
Line 173 
Line 174 
  
 private: private:
  
     //  
     CIMScope (const Uint32 scope);     CIMScope (const Uint32 scope);
     // Private member for storing he CIMScope  
     Uint32 cimScope;     Uint32 cimScope;
  
     friend class BinaryStreamer;     friend class BinaryStreamer;

Legend:
Removed from v.1.23  
changed lines
  Added in v.1.24
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2