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

Diff for /pegasus/src/Pegasus/Repository/Attic/Repository.cpp between version 1.3 and 1.8

version 1.3, 2001/01/28 04:11:03 version 1.8, 2001/02/17 00:35:57
Line 23 
Line 23 
 // Author: // Author:
 // //
 // $Log$ // $Log$
   // Revision 1.8  2001/02/17 00:35:57  bob
   // Addec <cstdio> for sprintf on linux
   //
   // Revision 1.7  2001/02/16 02:06:09  mike
   // Renamed many classes and headers.
   //
   // Revision 1.6  2001/02/13 07:00:18  mike
   // Added partial createInstance() method to repository.
   //
   // Revision 1.5  2001/02/11 05:45:33  mike
   // Added case insensitive logic for files in Repository
   //
   // Revision 1.4  2001/01/31 08:20:51  mike
   // Added dispatcher framework.
   // Added enumerateInstanceNames.
   //
 // Revision 1.3  2001/01/28 04:11:03  mike // Revision 1.3  2001/01/28 04:11:03  mike
 // fixed qualifier resolution // fixed qualifier resolution
 // //
Line 36 
Line 52 
 //END_HISTORY //END_HISTORY
  
 #include <cctype> #include <cctype>
   #include <cstdio>  // for sprintf on linux
 #include <fstream> #include <fstream>
 #include <Pegasus/Common/Pair.h> #include <Pegasus/Common/Pair.h>
 #include <Pegasus/Common/Destroyer.h> #include <Pegasus/Common/Destroyer.h>
Line 44 
Line 61 
 #include <Pegasus/Common/XmlReader.h> #include <Pegasus/Common/XmlReader.h>
 #include <Pegasus/Common/XmlWriter.h> #include <Pegasus/Common/XmlWriter.h>
 #include <Pegasus/Common/DeclContext.h> #include <Pegasus/Common/DeclContext.h>
   #include <Pegasus/Common/DeclContext.h>
 #include "Repository.h" #include "Repository.h"
   #include "InstanceIndexFile.h"
  
 #define INDENT_XML_FILES #define INDENT_XML_FILES
  
Line 88 
Line 107 
  
 Array<String> _GlobClassesDir( Array<String> _GlobClassesDir(
     const String& path,     const String& path,
     const String& className,      const String& className_,
     const String& superClassName)      const String& superClassName_)
 { {
       String className = className_;
       String superClassName = superClassName_;
     Array<String> fileNames;     Array<String> fileNames;
  
     if (!FileSystem::getDirectoryContents(path, fileNames))     if (!FileSystem::getDirectoryContents(path, fileNames))
Line 235 
Line 256 
     if (!FileSystem::isDirectory(path))     if (!FileSystem::isDirectory(path))
         throw CimException(CimException::INVALID_NAMESPACE);         throw CimException(CimException::INVALID_NAMESPACE);
  
     path.append('/');  
     path.append(QUALIFIERS);     path.append(QUALIFIERS);
     path.append(qualifierName);     path.append(qualifierName);
 } }
  
   static void _MakeInstanceIndexPath(
       const String& root,
       const String& nameSpace,
       const String& className,
       String& path)
   {
       const char INSTANCES[] = "/instances/";
       _MakeNameSpacePath(root, nameSpace, path);
   
       if (!FileSystem::isDirectory(path))
           throw CimException(CimException::INVALID_NAMESPACE);
   
       path.append(INSTANCES);
       path.append(className);
       path.append(".idx");
   }
   
   static void _MakeInstancePath(
       const String& root,
       const String& nameSpace,
       const String& className,
       Uint32 index,
       String& path)
   {
       const char INSTANCES[] = "/instances/";
       _MakeNameSpacePath(root, nameSpace, path);
   
       if (!FileSystem::isDirectory(path))
           throw CimException(CimException::INVALID_NAMESPACE);
   
       path.append(INSTANCES);
       path.append(className);
       path.append('.');
   
       char buffer[32];
       sprintf(buffer, "%d", index);
       path.append(buffer);
   }
   
 template<class Object> template<class Object>
 void _LoadObject( void _LoadObject(
     const String& path,     const String& path,
     Object& object)     Object& object)
 { {
     // Open the file:      // Get the real path of the file:
  
     Destroyer<char> destroyer(path.allocateCString());      String realPath;
     std::ifstream is(destroyer.getPointer());  
  
     if (!is)      if (!FileSystem::existsIgnoreCase(path, realPath))
         throw CannotOpenFile(path);         throw CannotOpenFile(path);
  
     // Load file into memory:     // Load file into memory:
  
     Array<Sint8> data;     Array<Sint8> data;
     FileSystem::loadFileToMemory(data, path);      FileSystem::loadFileToMemory(data, realPath);
     data.append('\0');     data.append('\0');
  
     XmlParser parser((char*)data.getData());     XmlParser parser((char*)data.getData());
Line 399 
Line 457 
  
     virtual ~RepositoryDeclContext();     virtual ~RepositoryDeclContext();
  
     virtual QualifierDecl lookupQualifierDecl(      virtual CIMQualifierDecl lookupQualifierDecl(
         const String& nameSpace,         const String& nameSpace,
         const String& qualifierName) const;         const String& qualifierName) const;
  
     virtual ClassDecl lookupClassDecl(      virtual CIMClass lookupClassDecl(
         const String& nameSpace,         const String& nameSpace,
         const String& className) const;         const String& className) const;
  
Line 423 
Line 481 
  
 } }
  
 QualifierDecl RepositoryDeclContext::lookupQualifierDecl(  CIMQualifierDecl RepositoryDeclContext::lookupQualifierDecl(
     const String& nameSpace,     const String& nameSpace,
     const String& qualifierName) const     const String& qualifierName) const
 { {
Line 436 
Line 494 
     }     }
     catch (Exception&)     catch (Exception&)
     {     {
         return QualifierDecl();          return CIMQualifierDecl();
     }     }
 } }
  
 ClassDecl RepositoryDeclContext::lookupClassDecl(  CIMClass RepositoryDeclContext::lookupClassDecl(
     const String& nameSpace,     const String& nameSpace,
     const String& className) const     const String& className) const
 { {
Line 453 
Line 511 
     }     }
     catch (Exception&)     catch (Exception&)
     {     {
         return ClassDecl();          return CIMClass();
     }     }
 } }
  
Line 483 
Line 541 
  
 } }
  
 ClassDecl Repository::getClass(  CIMClass Repository::getClass(
     const String& nameSpace,     const String& nameSpace,
     const String& className,     const String& className,
     Boolean localOnly,     Boolean localOnly,
Line 498 
Line 556 
  
     // Load the class:     // Load the class:
  
     ClassDecl classDecl;      CIMClass classDecl;
     _LoadObject(path, classDecl);     _LoadObject(path, classDecl);
  
     return ClassDecl(classDecl);      return CIMClass(classDecl);
 } }
  
 InstanceDecl Repository::getInstance(  CIMInstance Repository::getInstance(
     const String& nameSpace,     const String& nameSpace,
     const Reference& instanceName,      const CIMReference& instanceName,
     Boolean localOnly,     Boolean localOnly,
     Boolean includeQualifiers,     Boolean includeQualifiers,
     Boolean includeClassOrigin,     Boolean includeClassOrigin,
     const Array<String>& propertyList)     const Array<String>& propertyList)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return InstanceDecl();      return CIMInstance();
 } }
  
 void Repository::deleteClass( void Repository::deleteClass(
Line 540 
Line 598 
  
 void Repository::deleteInstance( void Repository::deleteInstance(
     const String& nameSpace,     const String& nameSpace,
     const Reference& instanceName)      const CIMReference& instanceName)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
 } }
  
 void Repository::createClass( void Repository::createClass(
     const String& nameSpace,     const String& nameSpace,
     ClassDecl& newClass)      CIMClass& newClass)
 { {
     // Form the path to the class:     // Form the path to the class:
  
     String path;     String path;
     const String& className = newClass.getClassName();     const String& className = newClass.getClassName();
     const String& superClassName = newClass.getSuperClassName();     const String& superClassName = newClass.getSuperClassName();
     _MakeNewClassPath(_root, nameSpace, className, superClassName, path);      _MakeNewClassPath(
           _root, nameSpace, className, superClassName, path);
  
     if (FileSystem::exists(path))      String realPath;
   
       if (FileSystem::existsIgnoreCase(path, realPath))
         throw CimException(CimException::ALREADY_EXISTS);         throw CimException(CimException::ALREADY_EXISTS);
       else
           realPath = path;
  
     // Validate the new class:     // Validate the new class:
  
Line 565 
Line 628 
  
     // Save the class:     // Save the class:
  
     _SaveObject(path, newClass);      _SaveObject(realPath, newClass);
 } }
  
 void Repository::createInstance( void Repository::createInstance(
     const String& nameSpace,     const String& nameSpace,
     const InstanceDecl& newInstance)      CIMInstance& newInstance)
 { {
     throw CimException(CimException::NOT_SUPPORTED);      // Form the reference to this instance:
   
       String instanceName;
   
   #if 0
       // ATTN: fix this:
       CIMReference::referenceToInstanceName(
           newInstance.makeReference(), instanceName);
   #else
       instanceName = "MyClass.key1=123456";
   #endif
   
       // Get the instance-name and create an entry
   
       String indexPath;
   
       _MakeInstanceIndexPath(
           _root, nameSpace, newInstance.getClassName(), indexPath);
   
       Uint32 index;
   
       if (!InstanceIndexFile::insert(indexPath, instanceName, index))
           throw CimException(CimException::FAILED);
   
       // Save the instance to file:
   
       String path;
   
       _MakeInstancePath(
           _root, nameSpace, newInstance.getClassName(), index, path);
   
       newInstance.resolve(_context, nameSpace);
   
       _SaveObject(path, newInstance);
 } }
  
 void Repository::modifyClass( void Repository::modifyClass(
     const String& nameSpace,     const String& nameSpace,
     ClassDecl& modifiedClass)      CIMClass& modifiedClass)
 { {
     // ATTN: need lots of semantic checking here:     // ATTN: need lots of semantic checking here:
  
     // Get the old class:     // Get the old class:
  
     ClassDecl oldClass = getClass(      CIMClass oldClass = getClass(
         nameSpace, modifiedClass.getClassName(), false, true, true);         nameSpace, modifiedClass.getClassName(), false, true, true);
  
     // Disallow changing the name of the super-class:     // Disallow changing the name of the super-class:
Line 602 
Line 698 
  
 void Repository::modifyInstance( void Repository::modifyInstance(
     const String& nameSpace,     const String& nameSpace,
     const InstanceDecl& modifiedInstance)      const CIMInstance& modifiedInstance)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
 } }
  
 Array<ClassDecl> Repository::enumerateClasses(  Array<CIMClass> Repository::enumerateClasses(
     const String& nameSpace,     const String& nameSpace,
     const String& className,     const String& className,
     Boolean deepInheritance,     Boolean deepInheritance,
Line 618 
Line 714 
     Array<String> classNames =     Array<String> classNames =
         enumerateClassNames(nameSpace, className, deepInheritance);         enumerateClassNames(nameSpace, className, deepInheritance);
  
     Array<ClassDecl> result;      Array<CIMClass> result;
  
     for (Uint32 i = 0; i < classNames.getSize(); i++)     for (Uint32 i = 0; i < classNames.getSize(); i++)
     {     {
Line 679 
Line 775 
     return Array<String>();     return Array<String>();
 } }
  
 Array<InstanceDecl> Repository::enumerateInstances(  Array<CIMInstance> Repository::enumerateInstances(
     const String& nameSpace,     const String& nameSpace,
     const String& className,     const String& className,
     Boolean deepInheritance,     Boolean deepInheritance,
Line 689 
Line 785 
     const Array<String>& propertyList)     const Array<String>& propertyList)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<InstanceDecl>();      return Array<CIMInstance>();
 } }
  
 Array<String> Repository::enumerateInstanceNames(  Array<CIMReference> Repository::enumerateInstanceNames(
     const String& nameSpace,     const String& nameSpace,
     const String& className)     const String& className)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<String>();      return Array<CIMReference>();
 } }
  
 Array<InstanceDecl> Repository::execQuery(  Array<CIMInstance> Repository::execQuery(
     const String& queryLanguage,     const String& queryLanguage,
     const String& query)     const String& query)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<InstanceDecl>();      return Array<CIMInstance>();
 } }
  
 Array<InstanceDecl> Repository::associators(  Array<CIMInstance> Repository::associators(
     const String& nameSpace,     const String& nameSpace,
     const Reference& objectName,      const CIMReference& objectName,
     const String& assocClass,     const String& assocClass,
     const String& resultClass,     const String& resultClass,
     const String& role,     const String& role,
Line 720 
Line 816 
     const Array<String>& propertyList)     const Array<String>& propertyList)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<InstanceDecl>();      return Array<CIMInstance>();
 } }
  
 Array<Reference> Repository::associatorNames(  Array<CIMReference> Repository::associatorNames(
     const String& nameSpace,     const String& nameSpace,
     const Reference& objectName,      const CIMReference& objectName,
     const String& assocClass,     const String& assocClass,
     const String& resultClass,     const String& resultClass,
     const String& role,     const String& role,
     const String& resultRole)     const String& resultRole)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<Reference>();      return Array<CIMReference>();
 } }
  
 Array<InstanceDecl> Repository::references(  Array<CIMInstance> Repository::references(
     const String& nameSpace,     const String& nameSpace,
     const Reference& objectName,      const CIMReference& objectName,
     const String& resultClass,     const String& resultClass,
     const String& role,     const String& role,
     Boolean includeQualifiers,     Boolean includeQualifiers,
Line 745 
Line 841 
     const Array<String>& propertyList)     const Array<String>& propertyList)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<InstanceDecl>();      return Array<CIMInstance>();
 } }
  
 Array<Reference> Repository::referenceNames(  Array<CIMReference> Repository::referenceNames(
     const String& nameSpace,     const String& nameSpace,
     const Reference& objectName,      const CIMReference& objectName,
     const String& resultClass,     const String& resultClass,
     const String& role)     const String& role)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Array<Reference>();      return Array<CIMReference>();
 } }
  
 Value Repository::getProperty(  CIMValue Repository::getProperty(
     const String& nameSpace,     const String& nameSpace,
     const Reference& instanceName,      const CIMReference& instanceName,
     const String& propertyName)     const String& propertyName)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Value();      return CIMValue();
 } }
  
 void Repository::setProperty( void Repository::setProperty(
     const String& nameSpace,     const String& nameSpace,
     const Reference& instanceName,      const CIMReference& instanceName,
     const String& propertyName,     const String& propertyName,
     const Value& newValue)      const CIMValue& newValue)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
 } }
  
 QualifierDecl Repository::getQualifier(  CIMQualifierDecl Repository::getQualifier(
     const String& nameSpace,     const String& nameSpace,
     const String& qualifierName)     const String& qualifierName)
 { {
Line 787 
Line 883 
  
     // If it does not exist:     // If it does not exist:
  
     if (!FileSystem::exists(path))      String realPath;
   
       if (!FileSystem::existsIgnoreCase(path, realPath))
         throw CimException(CimException::NOT_FOUND);         throw CimException(CimException::NOT_FOUND);
  
     // Load the qualifier:     // Load the qualifier:
  
     QualifierDecl qualifierDecl;      CIMQualifierDecl qualifierDecl;
     _LoadObject(path, qualifierDecl);      _LoadObject(realPath, qualifierDecl);
   
       // Return the qualifier:
  
     return QualifierDecl(qualifierDecl);      return CIMQualifierDecl(qualifierDecl);
 } }
  
 void Repository::setQualifier( void Repository::setQualifier(
     const String& nameSpace,     const String& nameSpace,
     const QualifierDecl& qualifierDecl)      const CIMQualifierDecl& qualifierDecl)
 { {
     // Form the path of the qualifier:     // Form the path of the qualifier:
  
Line 809 
Line 909 
  
     // If the qualifier already exists, delete it:     // If the qualifier already exists, delete it:
  
     if (FileSystem::exists(path))      String realPath;
   
       if (FileSystem::existsIgnoreCase(path, realPath))
     {     {
         if (!FileSystem::removeFile(path))          if (!FileSystem::removeFile(realPath))
             throw FailedToRemoveDirectory(path);             throw FailedToRemoveDirectory(path);
     }     }
       else
           realPath = path;
  
     // Write the qualifier to file:     // Write the qualifier to file:
  
     _SaveObject(path, qualifierDecl);      _SaveObject(realPath, qualifierDecl);
 } }
  
 void Repository::deleteQualifier( void Repository::deleteQualifier(
Line 827 
Line 931 
     String path;     String path;
     _MakeQualfierPath(_root, nameSpace, qualifierName, path);     _MakeQualfierPath(_root, nameSpace, qualifierName, path);
  
     if (!FileSystem::exists(path))      String realPath;
   
       if (!FileSystem::existsIgnoreCase(path, realPath))
         throw CimException(CimException::NOT_FOUND);         throw CimException(CimException::NOT_FOUND);
  
     if (!FileSystem::removeFile(path))      if (!FileSystem::removeFile(realPath))
         throw FailedToRemoveFile(path);         throw FailedToRemoveFile(path);
 } }
  
 Array<QualifierDecl> Repository::enumerateQualifiers(  Array<CIMQualifierDecl> Repository::enumerateQualifiers(
     const String& nameSpace)     const String& nameSpace)
 { {
     // Build the path to the qualifiers directory:     // Build the path to the qualifiers directory:
Line 856 
Line 962 
  
     // Load each qualifier into the result array:     // Load each qualifier into the result array:
  
     Array<QualifierDecl> result;      Array<CIMQualifierDecl> result;
  
     for (Uint32 i = 0, n = qualifierNames.getSize(); i < n; i++)     for (Uint32 i = 0, n = qualifierNames.getSize(); i < n; i++)
     {     {
         QualifierDecl tmp = getQualifier(nameSpace, qualifierNames[i]);          CIMQualifierDecl tmp = getQualifier(nameSpace, qualifierNames[i]);
         result.append(tmp);         result.append(tmp);
     }     }
  
     return result;     return result;
 } }
  
 Value Repository::invokeMethod(  CIMValue Repository::invokeMethod(
     const String& nameSpace,     const String& nameSpace,
     const Reference& instanceName,      const CIMReference& instanceName,
     const String& methodName,     const String& methodName,
     const Array<Value>& inParameters,      const Array<CIMValue>& inParameters,
     Array<Value>& outParameters)      Array<CIMValue>& outParameters)
 { {
     throw CimException(CimException::NOT_SUPPORTED);     throw CimException(CimException::NOT_SUPPORTED);
     return Value();      return CIMValue();
 } }
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
Line 945 
Line 1051 
  
 void Repository::createMetaQualifiers(const String& nameSpace) void Repository::createMetaQualifiers(const String& nameSpace)
 { {
     // Qualifier CimType : string = null,      // CIMQualifier CimType : string = null,
     //     Scope(property, parameter)      //     CIMScope(property, parameter)
  
     setQualifier(nameSpace, QualifierDecl("cimtype", String(),      setQualifier(nameSpace, CIMQualifierDecl("cimtype", String(),
         Scope::PROPERTY | Scope::REFERENCE | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::REFERENCE | CIMScope::PARAMETER));
  
     // Qualifier id : sint32 = null,      // CIMQualifier id : sint32 = null,
     //     Scope(any),      //     CIMScope(any),
     //     Flavor(toinstance)      //     CIMFlavor(toinstance)
  
     setQualifier(nameSpace, QualifierDecl("id", Sint32(0),      setQualifier(nameSpace, CIMQualifierDecl("id", Sint32(0),
         Scope::ANY,          CIMScope::ANY,
         Flavor::TOINSTANCE));          CIMFlavor::TOINSTANCE));
  
     // Qualifier OctetString : boolean = false, Scope(property)      // CIMQualifier OctetString : boolean = false, CIMScope(property)
  
     setQualifier(nameSpace, QualifierDecl("octetstring", false,      setQualifier(nameSpace, CIMQualifierDecl("octetstring", false,
         Scope::PROPERTY));          CIMScope::PROPERTY));
  
     // Qualifier Abstract : boolean = false,      // CIMQualifier Abstract : boolean = false,
     //     Scope(class, association, indication),      //     CIMScope(class, association, indication),
     //     Flavor(disableoverride, restricted);      //     CIMFlavor(disableoverride, restricted);
  
     setQualifier(nameSpace, QualifierDecl("abstract", false,      setQualifier(nameSpace, CIMQualifierDecl("abstract", false,
         Scope::CLASS | Scope::ASSOCIATION | Scope::INDICATION,          CIMScope::CLASS | CIMScope::ASSOCIATION | CIMScope::INDICATION,
         Flavor::NONE));          CIMFlavor::NONE));
  
     // Qualifier Aggregate : boolean = false,      // CIMQualifier Aggregate : boolean = false,
     //    Scope(reference),      //    CIMScope(reference),
     //    Flavor(disableoverride, tosubclass);      //    CIMFlavor(disableoverride, tosubclass);
  
     setQualifier(nameSpace, QualifierDecl("aggregate", false,      setQualifier(nameSpace, CIMQualifierDecl("aggregate", false,
         Scope::REFERENCE, Flavor::TOSUBCLASS));          CIMScope::REFERENCE, CIMFlavor::TOSUBCLASS));
  
     // Qualifier Aggregation : boolean = false,      // CIMQualifier Aggregation : boolean = false,
     //     Scope(association),      //     CIMScope(association),
     //     Flavor(disableoverride, tosubclass);      //     CIMFlavor(disableoverride, tosubclass);
  
     setQualifier(nameSpace, QualifierDecl("aggregation", false,      setQualifier(nameSpace, CIMQualifierDecl("aggregation", false,
         Scope::ASSOCIATION, Flavor::TOSUBCLASS));          CIMScope::ASSOCIATION, CIMFlavor::TOSUBCLASS));
  
     // Qualifier Alias : string = null,      // CIMQualifier Alias : string = null,
     //     Scope(property, reference, method),      //     CIMScope(property, reference, method),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
  
     setQualifier(nameSpace, QualifierDecl("alias", String(),      setQualifier(nameSpace, CIMQualifierDecl("alias", String(),
         Scope::PROPERTY | Scope::REFERENCE | Scope::METHOD,          CIMScope::PROPERTY | CIMScope::REFERENCE | CIMScope::METHOD,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier ArrayType : string = "Bag",      // CIMQualifier ArrayType : string = "Bag",
     //     Scope(property, parameter);      //     CIMScope(property, parameter);
  
     setQualifier(nameSpace, QualifierDecl("arraytype", "Bag",      setQualifier(nameSpace, CIMQualifierDecl("arraytype", "Bag",
         Scope::PROPERTY | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::PARAMETER));
  
     // Qualifier Association : boolean = false,      // CIMQualifier Association : boolean = false,
     //     Scope(class, association),      //     CIMScope(class, association),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("association", false,      setQualifier(nameSpace, CIMQualifierDecl("association", false,
         Scope::CLASS | Scope::ASSOCIATION,          CIMScope::CLASS | CIMScope::ASSOCIATION,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier BitMap : string[],      // CIMQualifier BitMap : string[],
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
  
     setQualifier(nameSpace, QualifierDecl("bitmap", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("bitmap", Array<String>(),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier BitValues : string[],      // CIMQualifier BitValues : string[],
     //     Scope(property, method, parameter),      //     CIMScope(property, method, parameter),
     //     Flavor(Translatable);      //     CIMFlavor(Translatable);
  
     setQualifier(nameSpace, QualifierDecl("bitvalues", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("bitvalues", Array<String>(),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER,          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier Counter : boolean = false,      // CIMQualifier Counter : boolean = false,
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
  
     setQualifier(nameSpace, QualifierDecl("counter", false,      setQualifier(nameSpace, CIMQualifierDecl("counter", false,
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier Delete : boolean = false,      // CIMQualifier Delete : boolean = false,
     //     Scope(association, reference);      //     CIMScope(association, reference);
  
     setQualifier(nameSpace, QualifierDecl("delete", false,      setQualifier(nameSpace, CIMQualifierDecl("delete", false,
         Scope::ASSOCIATION | Scope::REFERENCE));          CIMScope::ASSOCIATION | CIMScope::REFERENCE));
  
     // Qualifier Description : string = null,      // CIMQualifier Description : string = null,
     //     Scope(any),      //     CIMScope(any),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
  
     setQualifier(nameSpace, QualifierDecl("description", String(),      setQualifier(nameSpace, CIMQualifierDecl("description", String(),
         Scope::ANY,          CIMScope::ANY,
         Flavor::TRANSLATABLE));          CIMFlavor::TRANSLATABLE));
  
     // Qualifier DisplayName : string = null,      // CIMQualifier DisplayName : string = null,
     //     Scope(any),      //     CIMScope(any),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
  
     setQualifier(nameSpace, QualifierDecl("displayname", String(),      setQualifier(nameSpace, CIMQualifierDecl("displayname", String(),
         Scope::ANY,          CIMScope::ANY,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier Expensive : boolean = false,      // CIMQualifier Expensive : boolean = false,
     //     Scope(property, reference, method, class, association);      //     CIMScope(property, reference, method, class, association);
  
     setQualifier(nameSpace, QualifierDecl("expensive", false,      setQualifier(nameSpace, CIMQualifierDecl("expensive", false,
         Scope::PROPERTY | Scope::REFERENCE | Scope::METHOD | Scope::CLASS |          CIMScope::PROPERTY | CIMScope::REFERENCE | CIMScope::METHOD | CIMScope::CLASS |
         Scope::ASSOCIATION));          CIMScope::ASSOCIATION));
  
     // Qualifier Gauge : boolean = false,      // CIMQualifier Gauge : boolean = false,
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
  
     setQualifier(nameSpace, QualifierDecl("gauge", false,      setQualifier(nameSpace, CIMQualifierDecl("gauge", false,
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier Ifdeleted : boolean = false,      // CIMQualifier Ifdeleted : boolean = false,
     //     Scope(association, reference);      //     CIMScope(association, reference);
  
     setQualifier(nameSpace, QualifierDecl("ifdeleted", false,      setQualifier(nameSpace, CIMQualifierDecl("ifdeleted", false,
         Scope::ASSOCIATION | Scope::REFERENCE));          CIMScope::ASSOCIATION | CIMScope::REFERENCE));
  
     // Qualifier In : boolean = true,      // CIMQualifier In : boolean = true,
     //     Scope(parameter),      //     CIMScope(parameter),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("in", true,      setQualifier(nameSpace, CIMQualifierDecl("in", true,
         Scope::PARAMETER,          CIMScope::PARAMETER,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Indication : boolean = false,      // CIMQualifier Indication : boolean = false,
     //     Scope(class, indication),      //     CIMScope(class, indication),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("indication", false,      setQualifier(nameSpace, CIMQualifierDecl("indication", false,
         Scope::CLASS | Scope::INDICATION,          CIMScope::CLASS | CIMScope::INDICATION,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Invisible : boolean = false,      // CIMQualifier Invisible : boolean = false,
     //     Scope(reference, association, class, property, method);      //     CIMScope(reference, association, class, property, method);
  
     setQualifier(nameSpace, QualifierDecl("invisible", false,      setQualifier(nameSpace, CIMQualifierDecl("invisible", false,
         Scope::REFERENCE | Scope::ASSOCIATION | Scope::CLASS | Scope::PROPERTY |          CIMScope::REFERENCE | CIMScope::ASSOCIATION | CIMScope::CLASS | CIMScope::PROPERTY |
         Scope::METHOD));          CIMScope::METHOD));
  
     // Qualifier Key : boolean = false,      // CIMQualifier Key : boolean = false,
     //     Scope(property, reference),      //     CIMScope(property, reference),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("key", false,      setQualifier(nameSpace, CIMQualifierDecl("key", false,
         Scope::PROPERTY | Scope::REFERENCE,          CIMScope::PROPERTY | CIMScope::REFERENCE,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Large : boolean = false,      // CIMQualifier Large : boolean = false,
     //     Scope(property, class);      //     CIMScope(property, class);
  
     setQualifier(nameSpace, QualifierDecl("large", false,      setQualifier(nameSpace, CIMQualifierDecl("large", false,
         Scope::PROPERTY | Scope::CLASS));          CIMScope::PROPERTY | CIMScope::CLASS));
  
     // Qualifier MappingStrings : string[],      // CIMQualifier MappingStrings : string[],
     //     Scope(class, property, association, indication, reference);      //     CIMScope(class, property, association, indication, reference);
  
     setQualifier(nameSpace, QualifierDecl("mappingstrings", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("mappingstrings", Array<String>(),
         Scope::CLASS | Scope::PROPERTY | Scope::ASSOCIATION |          CIMScope::CLASS | CIMScope::PROPERTY | CIMScope::ASSOCIATION |
         Scope::INDICATION | Scope::REFERENCE));          CIMScope::INDICATION | CIMScope::REFERENCE));
  
     // Qualifier Max : uint32 = null, Scope(reference);      // CIMQualifier Max : uint32 = null, CIMScope(reference);
  
     setQualifier(nameSpace, QualifierDecl("max", Sint32(0),      setQualifier(nameSpace, CIMQualifierDecl("max", Sint32(0),
         Scope::PROPERTY | Scope::REFERENCE));          CIMScope::PROPERTY | CIMScope::REFERENCE));
  
     // Qualifier MaxLen : uint32 = null,      // CIMQualifier MaxLen : uint32 = null,
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
  
 #if 0 #if 0
     setQualifier(nameSpace, QualifierDecl("maxlen", Uint32(0),      setQualifier(nameSpace, CIMQualifierDecl("maxlen", Uint32(0),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
 #else #else
     setQualifier(nameSpace, QualifierDecl("maxlen", Sint32(0),      setQualifier(nameSpace, CIMQualifierDecl("maxlen", Sint32(0),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
 #endif #endif
  
     // Qualifier MaxValue : sint64 = null,      // CIMQualifier MaxValue : sint64 = null,
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
     // ATTN: XML schema requires sint32!     // ATTN: XML schema requires sint32!
  
     setQualifier(nameSpace, QualifierDecl("maxvalue", Sint32(0),      setQualifier(nameSpace, CIMQualifierDecl("maxvalue", Sint32(0),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier Min : sint32 = null, Scope(reference);      // CIMQualifier Min : sint32 = null, CIMScope(reference);
  
     setQualifier(nameSpace, QualifierDecl("min", Sint32(0),      setQualifier(nameSpace, CIMQualifierDecl("min", Sint32(0),
         Scope::REFERENCE));          CIMScope::REFERENCE));
  
     // Qualifier MinValue : sint64 = null,      // CIMQualifier MinValue : sint64 = null,
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
     // ATTN: Type expected by XML spec is sint32!      // ATTN: CIMType expected by XML spec is sint32!
  
     setQualifier(nameSpace, QualifierDecl("minvalue", Sint32(0),      setQualifier(nameSpace, CIMQualifierDecl("minvalue", Sint32(0),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier ModelCorrespondence : string[],      // CIMQualifier ModelCorrespondence : string[],
     //     Scope(property);      //     CIMScope(property);
  
     setQualifier(nameSpace, QualifierDecl("modelcorrespondence",      setQualifier(nameSpace, CIMQualifierDecl("modelcorrespondence",
         Array<String>(),         Array<String>(),
         Scope::PROPERTY));          CIMScope::PROPERTY));
  
     // Qualifier NonLocal : string = null,      // CIMQualifier NonLocal : string = null,
     //     Scope(reference);      //     CIMScope(reference);
  
     setQualifier(nameSpace, QualifierDecl("nonlocal", String(),      setQualifier(nameSpace, CIMQualifierDecl("nonlocal", String(),
         Scope::REFERENCE));          CIMScope::REFERENCE));
  
     // Qualifier NullValue : string = null,      // CIMQualifier NullValue : string = null,
     //     Scope(property),      //     CIMScope(property),
     //     Flavor(tosubclass, disableoverride);      //     CIMFlavor(tosubclass, disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("nullvalue", String(),      setQualifier(nameSpace, CIMQualifierDecl("nullvalue", String(),
         Scope::PROPERTY,          CIMScope::PROPERTY,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Out : boolean = false,      // CIMQualifier Out : boolean = false,
     //     Scope(parameter),      //     CIMScope(parameter),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("out", false,      setQualifier(nameSpace, CIMQualifierDecl("out", false,
         Scope::PARAMETER,          CIMScope::PARAMETER,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Override : string = null,      // CIMQualifier Override : string = null,
     //     Scope(property, method, reference),      //     CIMScope(property, method, reference),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("override", String(),      setQualifier(nameSpace, CIMQualifierDecl("override", String(),
         Scope::PROPERTY | Scope::METHOD | Scope::REFERENCE,          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::REFERENCE,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Propagated : string = null,      // CIMQualifier Propagated : string = null,
     //     Scope(property, reference),      //     CIMScope(property, reference),
     //     Flavor(disableoverride);      //     CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("propagated", String(),      setQualifier(nameSpace, CIMQualifierDecl("propagated", String(),
         Scope::PROPERTY | Scope::REFERENCE,          CIMScope::PROPERTY | CIMScope::REFERENCE,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Provider : string = null,      // CIMQualifier Provider : string = null,
     //     Scope(any);      //     CIMScope(any);
  
     setQualifier(nameSpace, QualifierDecl("provider", String(),      setQualifier(nameSpace, CIMQualifierDecl("provider", String(),
         Scope::ANY));          CIMScope::ANY));
  
     // Qualifier Read : boolean = true, Scope(property);      // CIMQualifier Read : boolean = true, CIMScope(property);
  
     setQualifier(nameSpace, QualifierDecl("read", true,      setQualifier(nameSpace, CIMQualifierDecl("read", true,
         Scope::PROPERTY));          CIMScope::PROPERTY));
  
     // Qualifier Required : boolean = false,      // CIMQualifier Required : boolean = false,
     //     Scope(property);      //     CIMScope(property);
  
     setQualifier(nameSpace, QualifierDecl("required", false,      setQualifier(nameSpace, CIMQualifierDecl("required", false,
         Scope::PROPERTY));          CIMScope::PROPERTY));
  
     // Qualifier Revision : string = null,      // CIMQualifier Revision : string = null,
     //     Scope(schema, class, association, indication),      //     CIMScope(schema, class, association, indication),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
     // ATTN: No such scope as Scope::SCHEMA      // ATTN: No such scope as CIMScope::SCHEMA
  
     setQualifier(nameSpace, QualifierDecl("revision", String(),      setQualifier(nameSpace, CIMQualifierDecl("revision", String(),
         Scope::CLASS | Scope::ASSOCIATION | Scope::INDICATION,          CIMScope::CLASS | CIMScope::ASSOCIATION | CIMScope::INDICATION,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier Schema : string = null,      // CIMQualifier Schema : string = null,
     //     Scope(property, method),      //     CIMScope(property, method),
     //     Flavor(disableoverride, translatable);      //     CIMFlavor(disableoverride, translatable);
  
     setQualifier(nameSpace, QualifierDecl("schema", String(),      setQualifier(nameSpace, CIMQualifierDecl("schema", String(),
         Scope::PROPERTY | Scope::METHOD,          CIMScope::PROPERTY | CIMScope::METHOD,
         Flavor::TOSUBCLASS | Flavor::TRANSLATABLE));          CIMFlavor::TOSUBCLASS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier Source : string = null,      // CIMQualifier Source : string = null,
     //     Scope(class, association, indication);      //     CIMScope(class, association, indication);
  
     setQualifier(nameSpace, QualifierDecl("source", String(),      setQualifier(nameSpace, CIMQualifierDecl("source", String(),
         Scope::CLASS | Scope::ASSOCIATION | Scope::INDICATION));          CIMScope::CLASS | CIMScope::ASSOCIATION | CIMScope::INDICATION));
  
     // Qualifier SourceType : string = null,      // CIMQualifier SourceType : string = null,
     //     Scope(class, association, indication,reference);      //     CIMScope(class, association, indication,reference);
  
     setQualifier(nameSpace, QualifierDecl("sourcetype", String(),      setQualifier(nameSpace, CIMQualifierDecl("sourcetype", String(),
         Scope::CLASS | Scope::ASSOCIATION | Scope:: INDICATION |          CIMScope::CLASS | CIMScope::ASSOCIATION | CIMScope:: INDICATION |
         Scope::REFERENCE));          CIMScope::REFERENCE));
  
     // Qualifier Static : boolean = false,      // CIMQualifier Static : boolean = false,
     //     Scope(property, method), Flavor(disableoverride);      //     CIMScope(property, method), CIMFlavor(disableoverride);
  
     setQualifier(nameSpace, QualifierDecl("static", false,      setQualifier(nameSpace, CIMQualifierDecl("static", false,
         Scope::PROPERTY | Scope::METHOD,          CIMScope::PROPERTY | CIMScope::METHOD,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Syntax : string = null,      // CIMQualifier Syntax : string = null,
     //     Scope(property, reference, method, parameter);      //     CIMScope(property, reference, method, parameter);
  
     setQualifier(nameSpace, QualifierDecl("syntax", String(),      setQualifier(nameSpace, CIMQualifierDecl("syntax", String(),
         Scope::PROPERTY | Scope::REFERENCE | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::REFERENCE | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier SyntaxType : string = null,      // CIMQualifier SyntaxType : string = null,
     //     Scope(property, reference, method, parameter);      //     CIMScope(property, reference, method, parameter);
  
     setQualifier(nameSpace, QualifierDecl("syntaxtype", String(),      setQualifier(nameSpace, CIMQualifierDecl("syntaxtype", String(),
         Scope::PROPERTY | Scope::REFERENCE | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::REFERENCE | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier Terminal : boolean = false,      // CIMQualifier Terminal : boolean = false,
     //     Scope(class);      //     CIMScope(class);
  
     setQualifier(nameSpace, QualifierDecl("terminal", false,      setQualifier(nameSpace, CIMQualifierDecl("terminal", false,
         Scope::CLASS));          CIMScope::CLASS));
  
     // Qualifier TriggerType : string = null,      // CIMQualifier TriggerType : string = null,
     //     Scope(class, property, reference, method, association, indication);      //     CIMScope(class, property, reference, method, association, indication);
  
     setQualifier(nameSpace, QualifierDecl("triggertype", String(),      setQualifier(nameSpace, CIMQualifierDecl("triggertype", String(),
         Scope::CLASS | Scope::PROPERTY | Scope::REFERENCE | Scope::METHOD |          CIMScope::CLASS | CIMScope::PROPERTY | CIMScope::REFERENCE | CIMScope::METHOD |
         Scope::ASSOCIATION | Scope::INDICATION));          CIMScope::ASSOCIATION | CIMScope::INDICATION));
  
     // Qualifier Units : string = null,      // CIMQualifier Units : string = null,
     //     Scope(property, method, parameter),      //     CIMScope(property, method, parameter),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
  
     setQualifier(nameSpace, QualifierDecl("units", String(),      setQualifier(nameSpace, CIMQualifierDecl("units", String(),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER,          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier UnknownValues : string[],      // CIMQualifier UnknownValues : string[],
     //     Scope(property),      //     CIMScope(property),
     //     Flavor(disableoverride, tosubclass);      //     CIMFlavor(disableoverride, tosubclass);
  
     setQualifier(nameSpace, QualifierDecl("unknownvalues", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("unknownvalues", Array<String>(),
         Scope::PROPERTY,          CIMScope::PROPERTY,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier UnsupportedValues : string[],      // CIMQualifier UnsupportedValues : string[],
     //     Scope(property),      //     CIMScope(property),
     //     Flavor(disableoverride, tosubclass);      //     CIMFlavor(disableoverride, tosubclass);
  
     setQualifier(nameSpace, QualifierDecl("unsupportedvalues", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("unsupportedvalues", Array<String>(),
         Scope::PROPERTY,          CIMScope::PROPERTY,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier ValueMap : string[],      // CIMQualifier ValueMap : string[],
     //     Scope(property, method, parameter);      //     CIMScope(property, method, parameter);
  
     setQualifier(nameSpace, QualifierDecl("valuemap", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("valuemap", Array<String>(),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER));          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER));
  
     // Qualifier Values : string[],      // CIMQualifier Values : string[],
     //     Scope(property, method, parameter),      //     CIMScope(property, method, parameter),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
  
     setQualifier(nameSpace, QualifierDecl("values", Array<String>(),      setQualifier(nameSpace, CIMQualifierDecl("values", Array<String>(),
         Scope::PROPERTY | Scope::METHOD | Scope::PARAMETER,          CIMScope::PROPERTY | CIMScope::METHOD | CIMScope::PARAMETER,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier Version : string = null,      // CIMQualifier Version : string = null,
     //     Scope(schema, class, association, indication),      //     CIMScope(schema, class, association, indication),
     //     Flavor(translatable);      //     CIMFlavor(translatable);
     // ATTN: No such scope as Scope::SCHEMA      // ATTN: No such scope as CIMScope::SCHEMA
  
     setQualifier(nameSpace, QualifierDecl("version", String(),      setQualifier(nameSpace, CIMQualifierDecl("version", String(),
         Scope::CLASS | Scope::ASSOCIATION | Scope::INDICATION,          CIMScope::CLASS | CIMScope::ASSOCIATION | CIMScope::INDICATION,
         Flavor::DEFAULTS | Flavor::TRANSLATABLE));          CIMFlavor::DEFAULTS | CIMFlavor::TRANSLATABLE));
  
     // Qualifier Weak : boolean = false,      // CIMQualifier Weak : boolean = false,
     //     Scope(reference),      //     CIMScope(reference),
     //     Flavor(disableoverride, tosubclass);      //     CIMFlavor(disableoverride, tosubclass);
  
     setQualifier(nameSpace, QualifierDecl("weak", false,      setQualifier(nameSpace, CIMQualifierDecl("weak", false,
         Scope::REFERENCE,          CIMScope::REFERENCE,
         Flavor::TOSUBCLASS));          CIMFlavor::TOSUBCLASS));
  
     // Qualifier Write : boolean = false,      // CIMQualifier Write : boolean = false,
     //     Scope(property);      //     CIMScope(property);
  
     setQualifier(nameSpace, QualifierDecl("write", false,      setQualifier(nameSpace, CIMQualifierDecl("write", false,
         Scope::PROPERTY));          CIMScope::PROPERTY));
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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