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

Diff for /pegasus/src/Pegasus/Common/CIMName.cpp between version 1.30 and 1.31

version 1.30, 2005/10/19 03:21:21 version 1.31, 2005/11/10 15:10:13
Line 40 
Line 40 
 #include <cctype> #include <cctype>
 #include "CIMName.h" #include "CIMName.h"
 #include "CommonUTF.h" #include "CommonUTF.h"
   #include "CharSet.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
Line 53 
Line 54 
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 CIMName::CIMName()  CIMName::CIMName(const String& name) : cimName(name)
 {  
 }  
   
 CIMName::CIMName(const String& name)  
     : cimName(name)  
 { {
     if (!legal(name))     if (!legal(name))
     {  
         throw InvalidNameException(name);         throw InvalidNameException(name);
     }     }
 }  
  
 CIMName::CIMName(const char* name)  CIMName::CIMName(const char* name) : cimName(name)
     : cimName(name)  
 { {
     if (!legal(name))     if (!legal(name))
     {  
         throw InvalidNameException(name);         throw InvalidNameException(name);
     }     }
 }  
   
 CIMName& CIMName::operator=(const CIMName& name)  
 {  
     cimName=name.cimName;  
     return *this;  
 }  
  
 CIMName& CIMName::operator=(const String& name) CIMName& CIMName::operator=(const String& name)
 { {
     if (!legal(name))     if (!legal(name))
     {  
         throw InvalidNameException(name);         throw InvalidNameException(name);
     }  
     cimName=name;     cimName=name;
     return *this;     return *this;
 } }
  
 const String& CIMName::getString() const  CIMName& CIMName::operator=(const char* name)
 {  
     return cimName;  
 }  
   
 Boolean CIMName::isNull() const  
 { {
     return (cimName.size() == 0);      if (!legal(name))
 }          throw InvalidNameException(name);
  
 void CIMName::clear()      cimName = name;
 {      return *this;
     cimName.clear();  
 } }
  
 Boolean CIMName::legal(const String& name) Boolean CIMName::legal(const String& name)
 { {
     Uint32 length = name.size();      // Check first character.
     Uint16 chkchr;  
   
     if (length == 0)  
         return false;  
  
     chkchr = name[0];      const Uint16* p = (const Uint16*)name.getChar16Data();
       size_t n = name.size();
  
     // First character must be alphabetic or '_' if ASCII      if (!(*p < 128 && CharSet::isAlphaUnder(*p)))
     if(!(  
          (chkchr == 0x005F) ||  
          ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||  
          ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||  
          ((chkchr >= 0x0080) && (chkchr <= 0xFFEF))))  
     {     {
           if (!(*p >= 0x0080 && *p <= 0xFFEF))
         return false;         return false;
     }     }
  
     // Remaining characters must be alphanumeric or '_' if ASCII      p++;
     for(Uint32 i = 1; i < length; ++i)      n--;
   
       // Use loop unrolling to skip over good ASCII 7-bit characters.
   
       while (n >= 4)
     {     {
         chkchr = name[i];          if (p[0] < 128 && CharSet::isAlNumUnder(p[0]) &&
         if(!(              p[1] < 128 && CharSet::isAlNumUnder(p[1]) &&
              (chkchr == 0x005F) ||              p[2] < 128 && CharSet::isAlNumUnder(p[2]) &&
              ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||              p[3] < 128 && CharSet::isAlNumUnder(p[3]))
              ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||  
              ((chkchr >= 0x0080) && (chkchr <= 0xFFEF)) ||  
              ((chkchr >= 0x0030) && (chkchr <= 0x0039))))  
         {         {
             return false;              p += 4;
         }              n -= 4;
               continue;
     }     }
  
     return true;          break;
 } }
  
 Boolean CIMName::equal(const CIMName& name) const      // Process remaining charcters.
 {  
     return String::equalNoCase(cimName, name.cimName);  
 }  
  
 Boolean operator==(const CIMName& name1, const CIMName& name2)      while (n)
 { {
     return name1.equal(name2);          if (!(*p < 128 && CharSet::isAlNumUnder(*p)))
 }  
   
 Boolean operator!=(const CIMName& name1, const CIMName& name2)  
 { {
     return !name1.equal(name2);              if (!(*p >= 0x0080 && *p <= 0xFFEF))
                   return false;
           }
           p++;
           n--;
 } }
  
       return true;
   }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 170 
Line 143 
 # include "ArrayImpl.h" # include "ArrayImpl.h"
 #undef PEGASUS_ARRAY_T #undef PEGASUS_ARRAY_T
  
 CIMNamespaceName::CIMNamespaceName()  inline void _check_namespace_name(String& name)
     : cimNamespaceName(String::EMPTY)  
 { {
       if (!CIMNamespaceName::legal(name))
           throw InvalidNamespaceNameException(name);
   
       if (name[0] == '/')
           name.remove(0, 1);
 } }
  
 CIMNamespaceName::CIMNamespaceName(const String& name) CIMNamespaceName::CIMNamespaceName(const String& name)
       : cimNamespaceName(name)
 { {
     *this = name;      _check_namespace_name(cimNamespaceName);
 } }
  
 CIMNamespaceName::CIMNamespaceName(const char* name) CIMNamespaceName::CIMNamespaceName(const char* name)
       : cimNamespaceName(name)
 { {
     *this = String(name);      _check_namespace_name(cimNamespaceName);
 } }
  
 CIMNamespaceName& CIMNamespaceName::operator=(const CIMNamespaceName& name) CIMNamespaceName& CIMNamespaceName::operator=(const CIMNamespaceName& name)
Line 193 
Line 172 
  
 CIMNamespaceName& CIMNamespaceName::operator=(const String& name) CIMNamespaceName& CIMNamespaceName::operator=(const String& name)
 { {
     if (!legal(name))  
     {  
         throw InvalidNamespaceNameException(name);  
     }  
   
     if (name[0] == '/')  
     {  
         // Strip off the meaningless leading '/'  
         cimNamespaceName=name.subString(1);  
     }  
     else  
     {  
         cimNamespaceName=name;         cimNamespaceName=name;
     }      _check_namespace_name(cimNamespaceName);
   
     return *this;     return *this;
 } }
  
 const String& CIMNamespaceName::getString() const  CIMNamespaceName& CIMNamespaceName::operator=(const char* name)
 {  
     return cimNamespaceName;  
 }  
   
 Boolean CIMNamespaceName::isNull() const  
 { {
     return (cimNamespaceName.size() == 0);      cimNamespaceName = name;
 }      _check_namespace_name(cimNamespaceName);
       return *this;
 void CIMNamespaceName::clear()  
 {  
     cimNamespaceName.clear();  
 } }
  
 Boolean CIMNamespaceName::legal(const String& name) Boolean CIMNamespaceName::legal(const String& name)
Line 249 
Line 207 
             return false;             return false;
         }         }
  
         Uint16 chkchr = name[index++];          Uint16 ch = name[index++];
  
         // First character must be alphabetic or '_' if ASCII         // First character must be alphabetic or '_' if ASCII
         if(!(  
              (chkchr == 0x005F) ||          if (!((ch >= 0x0080 && ch <= 0xFFEF) || CharSet::isAlphaUnder(ch)))
              ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||  
              ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||  
              ((chkchr >= 0x0080) && (chkchr <= 0xFFEF))))  
         {  
             return false;             return false;
         }  
  
         // Remaining characters must be alphanumeric or '_' if ASCII         // Remaining characters must be alphanumeric or '_' if ASCII
         while (index < length)         while (index < length)
         {         {
             chkchr = name[index++];              ch = name[index++];
  
             // A '/' indicates another namespace element follows             // A '/' indicates another namespace element follows
             if (chkchr == '/')              if (ch == '/')
             {             {
                 moreElements = true;                 moreElements = true;
                 break;                 break;
             }             }
  
             if(!(              if(!((ch >= 0x0080 && ch <= 0xFFEF) || CharSet::isAlNumUnder(ch)))
                  (chkchr == 0x005F) ||  
                  ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||  
                  ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||  
                  ((chkchr >= 0x0080) && (chkchr <= 0xFFEF)) ||  
                  ((chkchr >= 0x0030) && (chkchr <= 0x0039))))  
             {  
                 return false;                 return false;
             }             }
         }         }
     }  
  
     return true;     return true;
 } }
  
 Boolean CIMNamespaceName::equal(const CIMNamespaceName& name) const  Boolean operator==(const CIMNamespaceName& name1, const CIMNamespaceName& name2)
 { {
     return String::equalNoCase(cimNamespaceName, name.cimNamespaceName);      return name1.equal(name2);
 } }
  
 Boolean operator==(const CIMNamespaceName& name1, const CIMNamespaceName& name2)  Boolean operator==(const CIMNamespaceName& name1, const char* name2)
 { {
     return name1.equal(name2);     return name1.equal(name2);
 } }
  
   Boolean operator==(const char* name1, const CIMNamespaceName& name2)
   {
       return name2.equal(name1);
   }
   
 Boolean operator!=(const CIMNamespaceName& name1, const CIMNamespaceName& name2) Boolean operator!=(const CIMNamespaceName& name1, const CIMNamespaceName& name2)
 { {
     return !name1.equal(name2);     return !name1.equal(name2);
 } }
  
   Boolean operator!=(const CIMNamespaceName& name1, const char* name2)
   {
       return !name1.equal(name2);
   }
   
   Boolean operator!=(const char* name1, const CIMNamespaceName& name2)
   {
       return !name2.equal(name1);
   }
   
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END
   
   /*
   ================================================================================
   
   Optimizations:
   
       1. Optimized legal().
       2. Implmented "char*" version of operator=().
       3. Added conditional inlining (for Pegaus internal use).
       4. Added comparison functions for "char*".
       5. Implemented "unchecked" version of constructors and assignment operators
          that take String or "char*".
       6. Added loop unrolling to CIMName::legal()
   
   ================================================================================
   */

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