(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.6 and 1.7

version 1.6, 2001/02/13 07:00:18 version 1.7, 2001/02/16 02:06:09
Line 23 
Line 23 
 // Author: // Author:
 // //
 // $Log$ // $Log$
   // 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 // Revision 1.6  2001/02/13 07:00:18  mike
 // Added partial createInstance() method to repository. // Added partial createInstance() method to repository.
 // //
Line 450 
Line 453 
  
     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 474 
Line 477 
  
 } }
  
 QualifierDecl RepositoryDeclContext::lookupQualifierDecl(  CIMQualifierDecl RepositoryDeclContext::lookupQualifierDecl(
     const String& nameSpace,     const String& nameSpace,
     const String& qualifierName) const     const String& qualifierName) const
 { {
Line 487 
Line 490 
     }     }
     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 504 
Line 507 
     }     }
     catch (Exception&)     catch (Exception&)
     {     {
         return ClassDecl();          return CIMClass();
     }     }
 } }
  
Line 534 
Line 537 
  
 } }
  
 ClassDecl Repository::getClass(  CIMClass Repository::getClass(
     const String& nameSpace,     const String& nameSpace,
     const String& className,     const String& className,
     Boolean localOnly,     Boolean localOnly,
Line 549 
Line 552 
  
     // 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 591 
Line 594 
  
 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:
  
Line 626 
Line 629 
  
 void Repository::createInstance( void Repository::createInstance(
     const String& nameSpace,     const String& nameSpace,
     InstanceDecl& newInstance)      CIMInstance& newInstance)
 { {
     // Form the reference to this instance:     // Form the reference to this instance:
  
Line 634 
Line 637 
  
 #if 0 #if 0
     // ATTN: fix this:     // ATTN: fix this:
     Reference::referenceToInstanceName(      CIMReference::referenceToInstanceName(
         newInstance.makeReference(), instanceName);         newInstance.makeReference(), instanceName);
 #else #else
     instanceName = "MyClass.key1=123456";     instanceName = "MyClass.key1=123456";
Line 661 
Line 664 
  
     newInstance.resolve(_context, nameSpace);     newInstance.resolve(_context, nameSpace);
  
     std::cout << "path: " << path << std::endl;  
     _SaveObject(path, newInstance);     _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 692 
Line 694 
  
 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 708 
Line 710 
     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 769 
Line 771 
     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 779 
Line 781 
     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::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<Reference>();      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 810 
Line 812 
     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 835 
Line 837 
     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 884 
Line 886 
  
     // Load the qualifier:     // Load the qualifier:
  
     QualifierDecl qualifierDecl;      CIMQualifierDecl qualifierDecl;
     _LoadObject(realPath, qualifierDecl);     _LoadObject(realPath, qualifierDecl);
  
     // Return the qualifier:     // 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 934 
Line 936 
         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 956 
Line 958 
  
     // 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 1045 
Line 1047 
  
 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.6  
changed lines
  Added in v.1.7
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2