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

Diff for /pegasus/src/Pegasus/Common/CIMName.h between version 1.15 and 1.34

version 1.15, 2002/07/18 17:06:28 version 1.34, 2005/11/10 15:10:13
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2005////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001, 2002 BMC Software, Hewlett-Packard Company, IBM,  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
 // The Open Group, Tivoli Systems  // 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.
 // //
 // 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 21 
Line 27 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #ifndef Pegasus_Name_h #ifndef Pegasus_Name_h
 #define Pegasus_Name_h #define Pegasus_Name_h
  
 #include <Pegasus/Common/Config.h> #include <Pegasus/Common/Config.h>
   #include <Pegasus/Common/Linkage.h>
 #include <Pegasus/Common/String.h> #include <Pegasus/Common/String.h>
   #include <Pegasus/Common/Array.h>
   #include <Pegasus/Common/Exception.h>
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
   ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMName
   //
   ////////////////////////////////////////////////////////////////////////////////
   
 /** /**
     The name class defines static methods for handling CIM names.      The CIMName class defines methods for handling CIM names.
     There is no public constructor, and no instances can be created.  
     <p>     <p>
     The names of classes, properties, qualifiers, and methods are all     The names of classes, properties, qualifiers, and methods are all
     CIM names. A CIM name must match the following regular     CIM names. A CIM name must match the following regular
     expression:     expression:
     <PRE>     <PRE>
           [A-Za-z_][A-Za-z_0-9]*
         [A-Z-a-z_][A-Za-z_0-9]*  
     </PRE>     </PRE>
       <B>Examples:</B>
       <ul>
       <li>name - legal name
       <li>Type - legal name
       <li>3types - Illegal CIM name
       </ul>
       The CIMName class includes the attribute Null which is required
       by the DMTF operations definitions.  Note that this and the regular
       expression limits on CIMName are what separate this from the String
       class. This allows the names in CIM operations, such as getClass, to
       provide pattern matching tests for the classname parameter as well as
       separate the concept of empty from Null.
  
     Notice that the definition of a name is the same as C, C++,  
     and Java.  
   
     This class cannot be instantiated (since its only constructor is  
     private).  
 */ */
 class PEGASUS_COMMON_LINKAGE CIMName class PEGASUS_COMMON_LINKAGE CIMName
 { {
 public: public:
  
     //  ATTN: Define what is legal      /**
     /** legal - Determine if the name string input is legal as          Constructs an object with no name.  A call to isNull() immediately
         defnined in the CIMName class definition          after constructing the object will return true.
         @param - String to test  
         @return Returns true if the given name is legal.          @exception bad_alloc Thrown if there is insufficient memory.
     */      */
     static Boolean legal(const String& name) throw();      CIMName();
   
     /** equal - Compares two names.      /**
         @return Return true if the two names are equal. CIM names are          Constructor creates a new CIMName object from <TT>name</TT>.
         case insensitive and so it this method.          <TT>name</TT> must be a legal CIM name.
   
           @param name The name to use for the object.
           @exception InvalidNameException if <TT>name</TT> is not
                      a legal CIMName
           @exception bad_alloc Thrown if there is insufficient memory.
     */     */
     static Boolean equal(const String& name1, const String& name2) throw();      CIMName(const String& name);
   
       /**
           Constructor creates a new CIMName object from string
           provided as input. The string must be a legal name.
   
           @param name The name to use for the object.
           @exception InvalidNameException if <TT>name</TT> is not
                      a legal CIMName
           @exception bad_alloc Thrown if there is insufficient memory.
       */
       CIMName(const char* name);
   
       /**
           Assigns one CIMName to another.
   
           @param name CIMName object to copy.
           @exception bad_alloc Thrown if there is insufficient memory.
       */
       CIMName& operator=(const CIMName& name);
   
       /**
           Sets the name of the associated object to <TT>name</TT>.
   
           @param name The new name to use for the object.
           @exception InvalidNameException if <TT>name</TT> is not
                      a legal CIMName
           @exception bad_alloc Thrown if there is insufficient memory.
   
           <pre>
           CIMName n;
           String type = "type";
           n = type;
           </pre>
       */
       CIMName& operator=(const String& name);
   
       /**
           Gets a reference a String containing the name from the
           associated object.
   
           @return Reference to a String containing the name.
   
           <pre>
           CIMName n("name");
           String s = n.getString();
           </pre>
       */
       const String& getString() const;
   
       /**
           Tests if name is Null, i.e. not set.
   
           @return true if name is Null, false if not.
   
           <pre>
           CIMName n;
           assert(n.isNull());
           n = "name";
           assert(!n.isNull());
           </pre>
       */
       Boolean isNull() const;
   
       /**
           Clears the CIMName.
   
           <pre>
           CIMName n("name");
           n.clear();
           assert(n.isNull());
           </pre>
       */
       void clear();
   
       /**
           Compares the CIMName object against another CIMName object
           for equality.
   
           @param name CIMName to compare with the associated object.
           @return true if the name passed is equal to the name in this
           class. CIM names are case insensitive and so is this method.
           <pre>
           CIMName n1 = "name";
           CIMName n2 = "InstanceID";
           if( n1.equal(n2) )
                   ...                     // Should never get here
           else
                   ...
           </pre>
       */
       Boolean equal(const CIMName& name) const;
   
       /**
           Determines if the name string input is legal as
           defined in the CIMName class definition. This is a static
           method used to test String values to determine if they are
           legal names.
   
           @param name String to test for legality.
           @return Returns true if the name is legal, otherwise false.
   
           <pre>
           assert(CIMName::legal("name"));
           assert(!CIMName::legal("3types"));
           </pre>
       */
       static Boolean legal(const String& name);
   
   #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
   
       Boolean equal(const char* name) const;
   
       CIMName& operator=(const char* name);
   
   #endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */
  
 private: private:
       String cimName;
       friend class CIMNameUnchecked;
   };
   
   /**
       Compares two CIMNames to determine if they are equal.
   
       @param name1 One name to compare.
       @param name2 Another name to compare
       @return Returns true if the names are equal, false if they are not.
  
     CIMName() { }      CIMNames are not case sensitive, therefore the output of the
       following example is "Equal".
   
           <pre>
           CIMName lowerCaseName("this_is_a_name");
           CIMName upperCaseName("THIS_IS_A_NAME");
   
           if (lowerCaseName == upperCaseName)
           {
               puts("Equal");
           }
           else
           {
               puts("Not equal");
           }
           </pre>
    */
   PEGASUS_COMMON_LINKAGE Boolean operator==(
       const CIMName& name1,
       const CIMName& name2);
   
   /**
       Compares two CIMNames to determine if they are not equal.
   
       @param name1 One name to compare.
       @param name2 Another name to compare
       @return Returns true if the names are not equal, false if they are.
   
       The output of the following example is "Not equal".
   
           <pre>
           CIMName name1("this_is_a_name");
           CIMName name2("this is another_name");
   
           if (name1 != name2)
           {
               puts("Not equal");
           }
           else
           {
               puts("Equal");
           }
           </pre>
    */
   PEGASUS_COMMON_LINKAGE Boolean operator!=(
       const CIMName& name1,
       const CIMName& name2);
   
   #define PEGASUS_ARRAY_T CIMName
   # include "ArrayInter.h"
   #undef PEGASUS_ARRAY_T
   
   
   ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMNamespaceName
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   /**
       The CIMNamespaceName class defines methods for handling CIM namespace names.
       <p>
       A CIM namespace name must match the following expression:
       <PRE>
           &lt;CIMName&gt;[ / &lt;CIMName&gt; ]*
       </PRE>
       </p>
       <B>Examples</B>
       <UL>
       <LI>root
       <LI>root/test
       </UL>
       NOTE: Pegasus uses namespaces starting with the top level name (ex. root).  It does
       not use the form /root/test with a leading slash.  The legal() test method in this class
       allows that form as a legal entity however.
   */
   class PEGASUS_COMMON_LINKAGE CIMNamespaceName
   {
   public:
   
       /** Default constructor sets object Null. The Null state
               indicates that there is no name assigned to this object.
               The Null state can be tested with the isNull() method and
               set with the clear() method.
           */
       CIMNamespaceName();
   
       /** Constructor builds namespace from input String.
               The String input must be a legal namespace name.
               @param String from which the namespace object is built.
               This must be a legal namespace name.
               @exeception InvalidNamespaceName exception thrown if
               the namespace name input is illegal.
           */
       CIMNamespaceName(const String& name);
   
       /** Constructor builds namespace from input char*.
               The String input must be a legal namespace name.
               @param char* from which the namespace object is built.
               This must be a legal namespace name.
               @exeception InvalidNamespaceName exception thrown if
               the namespace name input parameter is illegal.
           */
       CIMNamespaceName(const char* name);
   
       /** Assign one namespace object to another.
                   @param CIMNamespaceName to assign to the object.
           */
       CIMNamespaceName& operator=(const CIMNamespaceName& name);
   
       /** Assign a String object to a CIMNamespaceName object.
                   @param CIMNamespaceName to assign
                   @exeception InvalidNamespaceName exception thrown if
                   the namespace name input parameter is illegal.
               <pre>
                           String s = "root/test";
                           CIMNamespacename ns;
                           ns = s;
               </pre>
           */
       CIMNamespaceName& operator=(const String& name);
   
       /** Extracts the String value of the CIMNamespaceName
               from the object.
               @return String containing the name.
               <pre>
                           CIMNamespaceName ns("root/test");
                           String s = ns.getString();
               </pre>
           */
       const String& getString() const;
   
       /** Tests the CIMNamespaceName for NULL attribute. Returns
               true if Null.  New objects without parameter and objects
               set with clear() are Null.  When a name is set into the
               object is is set to nonnull.  When the object is Null, it
               returns empty string.
               @return true if Null or false if not Null.
               <pre>
                           CIMName n;
                           assert(n.isNull());
                           n = "name";
                           assert(!n.isNull());
               </pre>
           */
       Boolean isNull() const;
   
       /** Clears the CIMNamespaceName and sets it to Null. A Null
               object contains no name so that accessing it with getString
               should return an empty String
               <pre>
                           CIMNamespaceName ns("root/test");
                           ns.clear();
                           assert(ns.isNull());
               </pre>
           */
       void clear();
   
       /** Compares two CIMNamespace objects for equality.
                   @return true if the name passed is equal to the name in this
           class. CIM names are case insensitive and so is this method.
                   <pre>
                   CIMNamespaceName ns("root/test");
                   CIMNamespaceName ns1("root/test");
                   assert( ns.equal(ns1);
               </pre>
       */
       Boolean equal(const CIMNamespaceName& name) const;
   
       /** Determines if the name string input is legal as
           defined in the CIMNamespaceName class definition.
           @param name String to test for legality.
           @return true if the given name is legal, false otherwise.
           <pre>
                   assert(CIMNamespaceName::legal("root/test"));
           </pre>
       */
       static Boolean legal(const String& name);
   
   #ifdef PEGASUS_USE_EXPERIMENTAL_INTERFACES
   
       Boolean equal(const char* name) const;
   
       CIMNamespaceName& operator=(const char* name);
   
   #endif /* PEGASUS_USE_EXPERIMENTAL_INTERFACES */
   
   private:
       String cimNamespaceName;
 }; };
  
   PEGASUS_COMMON_LINKAGE Boolean operator==(
       const CIMNamespaceName& name1,
       const CIMNamespaceName& name2);
   
   PEGASUS_COMMON_LINKAGE Boolean operator!=(
       const CIMNamespaceName& name1,
       const CIMNamespaceName& name2);
   
   #define PEGASUS_ARRAY_T CIMNamespaceName
   # include "ArrayInter.h"
   #undef PEGASUS_ARRAY_T
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
  
   #ifdef PEGASUS_INTERNALONLY
   # include "CIMNameInline.h"
   #endif
   
 #endif /* Pegasus_Name_h */ #endif /* Pegasus_Name_h */

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