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

Diff for /pegasus/src/Pegasus/Common/CIMQualifier.h between version 1.12 and 1.52

version 1.12, 2001/07/10 22:31:09 version 1.52, 2007/10/19 18:22:02
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec Corporation; The Open Group.
 // //
 // Permission is hereby granted, free of charge, to any person obtaining a copy // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to // of this software and associated documentation files (the "Software"), to
Line 20 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 /*  
  CIMQualifier.h - Defines the CIM qualifiers class.  
         This class represents a CIM qualifiers. It is almost identical to  
         CIMQualifierDecl except that it has no scope member.  
   
 */  
   
 #ifndef Pegasus_Qualifier_h #ifndef Pegasus_Qualifier_h
 #define Pegasus_Qualifier_h #define Pegasus_Qualifier_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
 #include <Pegasus/Common/CIMQualifierRep.h>  #include <Pegasus/Common/Linkage.h>
   #include <Pegasus/Common/CIMName.h>
   #include <Pegasus/Common/CIMFlavor.h>
   #include <Pegasus/Common/CIMType.h>
   #include <Pegasus/Common/CIMValue.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 49 
Line 51 
  
 class CIMConstQualifier; class CIMConstQualifier;
 class CIMClassRep; class CIMClassRep;
   class Resolver;
   class CIMQualifierRep;
  
 /** Class CIMQualifier - This class defines the Pegasus implementation of the  /**
     CIM CIMQualifier \Ref{QUALIFIER}.      A CIMQualifier represents a DMTF standard CIM qualifier.
       A CIMQualifier differs from a CIMQualifierDecl in that it has no scope
       attribute.
   
       <p>The CIMQualifier class uses a shared representation model, such that
       multiple CIMQualifier objects may refer to the same data copy.  Assignment
       and copy operators create new references to the same data, not distinct
       copies.  An update to a CIMQualifier object affects all the CIMQualifier
       objects that refer to the same data copy.  The data remains valid until
       all the CIMQualifier objects that refer to it are destructed.  A separate
       copy of the data may be created using the clone method.
 */ */
 class PEGASUS_COMMON_LINKAGE CIMQualifier class PEGASUS_COMMON_LINKAGE CIMQualifier
 { {
 public: public:
  
     /** Constructor instantiates a CIM qualifier with empty name value      /**
         fields.Constructor          Constructs an uninitialized CIMQualifier object.  A method
         @return instantiated empty qualifier object          invocation on an uninitialized object will result in the throwing
     */          of an UninitializedObjectException.  An uninitialized object may
     CIMQualifier() : _rep(0)          be converted into an initialized object only by using the assignment
     {          operator with an initialized object.
       */
     }      CIMQualifier();
   
     /** Constructor - instantiates a CIM qualifier object from another      /**
     qualifier object.          Constructs a CIMQualifier object from the value of a specified
     @param CIM CIMQualifier object          CIMQualifier object, so that both objects refer to the same data copy.
     ATTN: What is differenc from clone?          @param x The CIMQualifier object from which to construct a new
     @return - Instantiated qualifier object              CIMQualifier object.
  */      */
     CIMQualifier(const CIMQualifier& x)      CIMQualifier(const CIMQualifier& x);
     {  
         Inc(_rep = x._rep);      /**
     }          Constructs a CIMQualifier object with the specified attributes.
     /** Constructor - Instantiates a CIM qualifier object with the parameters          @param name A CIMName specifying the name of the qualifier.
     defined on input.          @param value A CIMValue specifying the qualifier value, and implicitly
     @param String representing CIMName for the new qualifier              defining the qualifier type and whether the qualifier is an Array
     @param value              qualifier.
     @param flavor - ATTN:          @param flavor A CIMFlavor indicating the qualifier flavors.
     @param propoagated - ATTN:          @param propagated A Boolean indicating whether the qualifier is local
     @return -Returns the instantiated qualifier object or throws an exception              to the context in which it appears or was propagated
     if the name argument is illegal              (without modification) from other schema.
           @exception UninitializedObjectException If the qualifier name is null.
     @exception Throws IllegalName if name argument not legal CIM  
     identifier.  
      */      */
     CIMQualifier(     CIMQualifier(
         const String& name,          const CIMName& name,
         const CIMValue& value,         const CIMValue& value,
         Uint32 flavor = CIMFlavor::DEFAULTS,          const CIMFlavor & flavor = CIMFlavor (CIMFlavor::NONE),
         Boolean propagated = false)          Boolean propagated = false);
     {  
         _rep = new CIMQualifierRep(name, value, flavor, propagated);  
     }  
     /// destructor  
     ~CIMQualifier()  
     {  
         Dec(_rep);  
     }  
     /// operator  
     CIMQualifier& operator=(const CIMQualifier& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
   
         return *this;  
     }  
   
     /** CIMMethod  
   
     */  
     const String& getName() const  
     {  
         _checkRep();  
         return _rep->getName();  
     }  
   
     /** CIMMethod  
      Throws IllegalName if name argument not legal CIM  identifier.  
     */  
     void setName(const String& name)  
     {  
         _checkRep();  
         _rep->setName(name);  
     }  
   
     /** CIMMethod  
   
     */  
     CIMType getType() const  
     {  
         _checkRep();  
         return _rep->getType();  
     }  
   
     /** CIMMethod  
  
       /**
           Destructs the CIMQualifier object.
     */     */
     Boolean isArray() const      ~CIMQualifier();
     {  
         _checkRep();  
         return _rep->isArray();  
     }  
   
     /** CIMMethod  
   
     */  
     const CIMValue& getValue() const  
     {  
         _checkRep();  
         return _rep->getValue();  
     }  
   
     /** CIMMethod  
   
     */  
     void setValue(const CIMValue& value)  
     {  
         _checkRep();  
         _rep->setValue(value);  
     }  
   
     /** CIMMethod  
   
     */  
     Uint32 getFlavor() const  
     {  
         _checkRep();  
         return _rep->getFlavor();  
     }  
   
     /** CIMMethod  
   
    */  
     const Uint32 getPropagated() const  
     {  
         _checkRep();  
         return _rep->getPropagated();  
     }  
   
     /** CIMMethod  
   
     */  
     void setPropagated(Boolean propagated)  
     {  
         _checkRep();  
         _rep->setPropagated(propagated);  
     }  
   
     /** CIMMethod  
   
     */  
     operator int() const { return _rep != 0; }  
   
     /** CIMMethod  
   
     */  
     void toXml(Array<Sint8>& out) const  
     {  
         _checkRep();  
         _rep->toXml(out);  
     }  
   
     /** CIMMethod  
   
    */  
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  
     {  
         _checkRep();  
         _rep->print(o);  
     }  
   
     /** CIMMethod  
  
       /**
           Assigns the value of the specified CIMQualifier object to this
           object, so that both objects refer to the same data copy.
           @param x The CIMQualifier object from which to assign this
               CIMQualifier object.
           @return A reference to this CIMQualifier object.
       */
       CIMQualifier& operator=(const CIMQualifier& x);
   
       /**
           Gets the name of the qualifier.
           @return A CIMName containing the name of the qualifier.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMName& getName() const;
   
       /**
           Sets the qualifier name.
           @param name A CIMName containing the new name of the qualifier.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void setName(const CIMName& name);
   
       /**
           Gets the qualifier type.
           @return A CIMType containing the qualifier type.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMType getType() const;
   
       /**
           Checks whether the qualifier is an Array qualifier.
           @return True if the qualifier is an Array qualifier, false otherwise.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Boolean isArray() const;
   
       /**
           Gets the qualifier value.
           @return A CIMValue containing the qualifier value.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMValue& getValue() const;
   
       /**
           Sets the qualifier value.
           @param name A CIMValue containing the new value of the qualifier.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void setValue(const CIMValue& value);
   
       /**
           Adds flavors to the qualifier.
           @param flavor A CIMFlavor indicating the flavors to add.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void setFlavor(const CIMFlavor & flavor);
   
       /**
           Removes flavors from the qualifier.
           @param flavor A CIMFlavor indicating the flavors to remove.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void unsetFlavor(const CIMFlavor & flavor);
   
       /**
           Gets the qualifier flavors.
           @return A CIMFlavor containing the qualifier flavor settings.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMFlavor & getFlavor() const;
   
       /**
           Tests the propagated attribute of the qualifier.  The propagated
           attribute indicates whether this qualifier was propagated from a
           higher-level class.  Normally this attribute is set as part of
           defining a qualifier in the context of a schema.  It is set in
           qualifiers retrieved from a CIM Server.
           (Note: Although this method is intended to return a Boolean value,
           changing the return type would break interface compatibility.)
           @return Non-zero if qualifier is propagated, otherwise zero.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 getPropagated() const;
   
       /**
           Sets the propagated attribute.  Normally this is used by a CIM Server
           when defining a qualifier in the context of a schema.
           @param propagated A Boolean indicating whether the qualifier is
               propagated.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       void setPropagated(Boolean propagated);
   
       /**
           Determines whether the object has been initialized.
           @return True if the object has not been initialized, false otherwise.
       */
       Boolean isUninitialized() const;
   
       /**
           Compares the qualifier with another qualifier.
           @param x The CIMConstQualifier to be compared.
           @return True if this qualifier is identical to the one specified,
               false otherwise.
           @exception UninitializedObjectException If either of the objects
               is not initialized.
    */    */
     Boolean identical(const CIMConstQualifier& x) const;     Boolean identical(const CIMConstQualifier& x) const;
  
     /** CIMMethod      /**
           Makes a deep copy of the qualifier.  This creates a new copy
           of all the qualifier attributes.
           @return A new copy of the CIMQualifier object.
           @exception UninitializedObjectException If the object is not
               initialized.
     */     */
     CIMQualifier clone() const      CIMQualifier clone() const;
     {  
         return CIMQualifier(_rep->clone());  
     }  
  
 private: private:
  
     CIMQualifier(CIMQualifierRep* rep) : _rep(rep)      CIMQualifier(CIMQualifierRep* rep);
     {  
     }  
   
     void _checkRep() const  
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
  
     CIMQualifierRep* _rep;     CIMQualifierRep* _rep;
   
     friend class CIMConstQualifier;     friend class CIMConstQualifier;
     friend class CIMClassRep;     friend class CIMClassRep;
       friend class Resolver;
       friend class XmlWriter;
       friend class MofWriter;
       friend class BinaryStreamer;
 }; };
  
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // CIMConstQualifier // CIMConstQualifier
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   /**
       The CIMConstQualifier class provides a const interface to a CIMQualifier
       object.  This class is needed because the shared representation model
       used by CIMQualifier does not prevent modification to a const CIMQualifier
       object.  Note that the value of a CIMConstQualifier object could still be
       modified by a CIMQualifier object that refers to the same data copy.
   */
 class PEGASUS_COMMON_LINKAGE CIMConstQualifier class PEGASUS_COMMON_LINKAGE CIMConstQualifier
 { {
 public: public:
  
     CIMConstQualifier() : _rep(0)      /**
     {          Constructs an uninitialized CIMConstQualifier object.  A method
           invocation on an uninitialized object will result in the throwing
     }          of an UninitializedObjectException.  An uninitialized object may
           be converted into an initialized object only by using the assignment
     CIMConstQualifier(const CIMConstQualifier& x)          operator with an initialized object.
     {      */
         Inc(_rep = x._rep);      CIMConstQualifier();
     }  
       /**
     CIMConstQualifier(const CIMQualifier& x)          Constructs a CIMConstQualifier object from the value of a specified
     {          CIMConstQualifier object, so that both objects refer to the same data
         Inc(_rep = x._rep);          copy.
     }          @param x The CIMConstQualifier object from which to construct a new
               CIMConstQualifier object.
     // Throws IllegalName if name argument not legal CIM identifier.      */
       CIMConstQualifier(const CIMConstQualifier& x);
   
       /**
           Constructs a CIMConstQualifier object from the value of a specified
           CIMQualifier object, so that both objects refer to the same data
           copy.
           @param x The CIMQualifier object from which to construct a new
               CIMConstQualifier object.
       */
       CIMConstQualifier(const CIMQualifier& x);
   
       /**
           Constructs a CIMConstQualifier object with the specified attributes.
           @param name A CIMName specifying the name of the qualifier.
           @param value A CIMValue specifying the qualifier value, and implicitly
               defining the qualifier type and whether the qualifier is an Array
               qualifier.
           @param flavor A CIMFlavor indicating the qualifier flavors.
           @param propagated A Boolean indicating whether the qualifier is local
               to the context in which it appears or was propagated
               (without modification) from other schema.
           @exception UninitializedObjectException If the qualifier name is null.
       */
     CIMConstQualifier(     CIMConstQualifier(
         const String& name,          const CIMName& name,
         const CIMValue& value,         const CIMValue& value,
         Uint32 flavor = CIMFlavor::DEFAULTS,          const CIMFlavor & flavor = CIMFlavor (CIMFlavor::NONE),
         Boolean propagated = false)          Boolean propagated = false);
     {  
         _rep = new CIMQualifierRep(name, value, flavor, propagated);  
     }  
   
     ~CIMConstQualifier()  
     {  
         Dec(_rep);  
     }  
   
     CIMConstQualifier& operator=(const CIMConstQualifier& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
   
         return *this;  
     }  
   
     CIMConstQualifier& operator=(const CIMQualifier& x)  
     {  
         if (x._rep != _rep)  
         {  
             Dec(_rep);  
             Inc(_rep = x._rep);  
         }  
   
         return *this;  
     }  
   
     const String& getName() const  
     {  
         _checkRep();  
         return _rep->getName();  
     }  
   
     CIMType getType() const  
     {  
         _checkRep();  
         return _rep->getType();  
     }  
   
     Boolean isArray() const  
     {  
         _checkRep();  
         return _rep->isArray();  
     }  
   
     const CIMValue& getValue() const  
     {  
         _checkRep();  
         return _rep->getValue();  
     }  
   
     const Uint32 getFlavor() const  
     {  
         _checkRep();  
         return _rep->getFlavor();  
     }  
   
     const Uint32 getPropagated() const  
     {  
         _checkRep();  
         return _rep->getPropagated();  
     }  
  
     operator int() const { return _rep != 0; }      /**
           Destructs the CIMQualifier object.
     void toXml(Array<Sint8>& out) const      */
     {      ~CIMConstQualifier();
         _checkRep();  
         _rep->toXml(out);  
     }  
   
     void print(PEGASUS_STD(ostream) &o=PEGASUS_STD(cout)) const  
     {  
         _checkRep();  
         _rep->print(o);  
     }  
  
     Boolean identical(const CIMConstQualifier& x) const      /**
     {          Assigns the value of the specified CIMConstQualifier object to this
         x._checkRep();          object, so that both objects refer to the same data copy.
         _checkRep();          @param x The CIMConstQualifier object from which to assign this
         return _rep->identical(x._rep);              CIMConstQualifier object.
     }          @return A reference to this CIMConstQualifier object.
       */
       CIMConstQualifier& operator=(const CIMConstQualifier& x);
   
       /**
           Assigns the value of the specified CIMQualifier object to this
           object, so that both objects refer to the same data copy.
           @param x The CIMQualifier object from which to assign this
               CIMConstQualifier object.
           @return A reference to this CIMConstQualifier object.
       */
       CIMConstQualifier& operator=(const CIMQualifier& x);
   
       /**
           Gets the name of the qualifier.
           @return A CIMName containing the name of the qualifier.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMName& getName() const;
   
       /**
           Gets the qualifier type.
           @return A CIMType containing the qualifier type.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMType getType() const;
   
       /**
           Checks whether the qualifier is an Array qualifier.
           @return True if the qualifier is an Array qualifier, false otherwise.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Boolean isArray() const;
   
       /**
           Gets the qualifier value.
           @return A CIMValue containing the qualifier value.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMValue& getValue() const;
   
       /**
           Gets the qualifier flavors.
           @return A CIMFlavor containing the qualifier flavor settings.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       const CIMFlavor & getFlavor() const;
   
       /**
           Tests the propagated attribute of the qualifier.  The propagated
           attribute indicates whether this qualifier was propagated from a
           higher-level class.  Normally this attribute is set as part of
           defining a qualifier in the context of a schema.  It is set in
           qualifiers retrieved from a CIM Server.
           (Note: Although this method is intended to return a Boolean value,
           changing the return type would break interface compatibility.)
           @return Non-zero if qualifier is propagated, otherwise zero.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       Uint32 getPropagated() const;
   
       /**
           Determines whether the object has been initialized.
           @return True if the object has not been initialized, false otherwise.
       */
       Boolean isUninitialized() const;
   
       /**
           Compares the qualifier with another qualifier.
           @param x The CIMConstQualifier to be compared.
           @return True if this qualifier is identical to the one specified,
               false otherwise.
           @exception UninitializedObjectException If either of the objects
               is not initialized.
       */
       Boolean identical(const CIMConstQualifier& x) const;
  
     CIMQualifier clone() const      /**
     {          Makes a deep copy of the qualifier.  This creates a new copy
         return CIMQualifier(_rep->clone());          of all the qualifier attributes.
     }          @return A CIMQualifier object with a separate copy of the
               CIMConstQualifier object.
           @exception UninitializedObjectException If the object is not
               initialized.
       */
       CIMQualifier clone() const;
  
 private: private:
  
     void _checkRep() const  
     {  
         if (!_rep)  
             ThrowUnitializedHandle();  
     }  
   
     CIMQualifierRep* _rep;     CIMQualifierRep* _rep;
   
     friend class CIMQualifier;     friend class CIMQualifier;
       friend class XmlWriter;
       friend class MofWriter;
 }; };
  
 PEGASUS_MEMORY_FUNCTIONS(CIMQualifier)  
 PEGASUS_MEMORY_FUNCTIONS(CIMQualifier*)  
   
 #define PEGASUS_ARRAY_T CIMQualifier #define PEGASUS_ARRAY_T CIMQualifier
 # include "ArrayInter.h"  # include <Pegasus/Common/ArrayInter.h>
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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