(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.11 and 1.26

version 1.11, 2002/06/01 00:56:25 version 1.26, 2004/06/15 18:38:24
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2003////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 23 
Line 25 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Roger Kumpf, Hewlett Packard Company (roger_kumpf@hp.com)
   //              Carol Ann Krug Graves, Hewlett-Packard Company
   //                (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include <cctype> #include <cctype>
 #include "CIMName.h" #include "CIMName.h"
   #include "CommonUTF.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
  
 Boolean CIMName::legal(const Char16* name) throw()  ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMName
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   #define PEGASUS_ARRAY_T CIMName
   # include "ArrayImpl.h"
   #undef PEGASUS_ARRAY_T
   
   CIMName::CIMName()
       : cimName(String::EMPTY)
   {
   }
   
   CIMName::CIMName(const String& name)
       : cimName(name)
   {
       if (!legal(name))
       {
           throw InvalidNameException(name);
       }
   }
   
   CIMName::CIMName(const char* name)
       : cimName(name)
   {
       if (!legal(name))
       {
           throw InvalidNameException(name);
       }
   }
   
   CIMName& CIMName::operator=(const CIMName& name)
   {
       cimName=name.cimName;
       return *this;
   }
   
   CIMName& CIMName::operator=(const String& name)
   {
       if (!legal(name))
       {
           throw InvalidNameException(name);
       }
       cimName=name;
       return *this;
   }
   
   const String& CIMName::getString() const
   {
       return cimName;
   }
   
   Boolean CIMName::isNull() const
   {
       return (cimName.size() == 0);
   }
   
   void CIMName::clear()
   {
       cimName.clear();
   }
   
   Boolean CIMName::legal(const String& name)
 { {
     const Char16* p = name;      Uint32 length = name.size();
       Uint16 chkchr;
   
       if (length == 0)
           return false;
   
       chkchr = name[0];
   
       // First character must be alphabetic or '_' if ASCII
       if(!(
            (chkchr == 0x005F) ||
            ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||
            ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||
            ((chkchr >= 0x0080) && (chkchr <= 0xFFEF))))
       {
           return false;
       }
  
     if (!p)      // Remaining characters must be alphanumeric or '_' if ASCII
       for(Uint32 i = 1; i < length; ++i)
       {
           chkchr = name[i];
           if(!(
                (chkchr == 0x005F) ||
                ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||
                ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||
                ((chkchr >= 0x0080) && (chkchr <= 0xFFEF)) ||
                ((chkchr >= 0x0030) && (chkchr <= 0x0039))))
           {
         return false;         return false;
         //throw NullPointer();  // No apparent need for an exception here          }
       }
   
       return true;
   }
   
   Boolean CIMName::equal(const CIMName& name) const
   {
       return String::equalNoCase(cimName, name.cimName);
   }
   
   Boolean operator==(const CIMName& name1, const CIMName& name2)
   {
       return name1.equal(name2);
   }
   
  
     if (!*p || !(isalpha(*p) || *p == '_'))  ////////////////////////////////////////////////////////////////////////////////
   //
   // CIMNamespaceName
   //
   ////////////////////////////////////////////////////////////////////////////////
   
   #define PEGASUS_ARRAY_T CIMNamespaceName
   # include "ArrayImpl.h"
   #undef PEGASUS_ARRAY_T
   
   CIMNamespaceName::CIMNamespaceName()
       : cimNamespaceName(String::EMPTY)
   {
   }
   
   CIMNamespaceName::CIMNamespaceName(const String& name)
   {
       *this = name;
   }
   
   CIMNamespaceName::CIMNamespaceName(const char* name)
   {
       *this = String(name);
   }
   
   CIMNamespaceName& CIMNamespaceName::operator=(const CIMNamespaceName& name)
   {
       cimNamespaceName=name.cimNamespaceName;
       return *this;
   }
   
   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;
       }
   
       return *this;
   }
   
   const String& CIMNamespaceName::getString() const
   {
       return cimNamespaceName;
   }
   
   Boolean CIMNamespaceName::isNull() const
   {
       return (cimNamespaceName.size() == 0);
   }
   
   void CIMNamespaceName::clear()
   {
       cimNamespaceName.clear();
   }
   
   Boolean CIMNamespaceName::legal(const String& name)
   {
       Uint32 length = name.size();
       Uint32 index = 0;
   
       // Skip a leading '/' because the CIM specification is ambiguous
       if (name[0] == '/')
       {
           index++;
       }
   
       Boolean moreElements = true;
   
       // Check each namespace element (delimited by '/' characters)
       while (moreElements)
       {
           moreElements = false;
   
           if (index == length)
           {
         return false;         return false;
           }
  
     for (p++; *p; p++)          Uint16 chkchr = name[index++];
   
           // First character must be alphabetic or '_' if ASCII
           if(!(
                (chkchr == 0x005F) ||
                ((chkchr >= 0x0041) && (chkchr <= 0x005A)) ||
                ((chkchr >= 0x0061) && (chkchr <= 0x007A)) ||
                ((chkchr >= 0x0080) && (chkchr <= 0xFFEF))))
     {     {
 #ifdef PEGASUS_HAS_EBCDIC  
         if (*p > 255)  
 #else  
         if (*p > 127)  
 #endif  
             return false;             return false;
           }
   
           // Remaining characters must be alphanumeric or '_' if ASCII
           while (index < length)
           {
               chkchr = name[index++];
   
               // A '/' indicates another namespace element follows
               if (chkchr == '/')
               {
                   moreElements = true;
                   break;
               }
  
         if (!(isalnum(*p) || *p == '_'))              if(!(
                    (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 CIMName::legal(const String& name) throw()  Boolean CIMNamespaceName::equal(const CIMNamespaceName& name) const
 { {
     return legal(name.getData());      return String::equalNoCase(cimNamespaceName, name.cimNamespaceName);
 } }
  
 Boolean CIMName::equal(const String& name1, const String& name2) throw()  Boolean operator==(const CIMNamespaceName& name1, const CIMNamespaceName& name2)
 { {
     return String::equalNoCase(name1, name2);      return name1.equal(name2);
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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