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

Diff for /pegasus/src/Pegasus/Common/CIMQualifierRep.cpp between version 1.10.2.2 and 1.48

version 1.10.2.2, 2001/08/06 14:39:03 version 1.48, 2008/03/05 21:31:45
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2006////////////////////////////////////////////////////////////////////////
 // //
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  // Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development
   // Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems.
   // Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation, The Open Group.
   // Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.;
   // IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; VERITAS Software Corporation; The Open Group.
   // Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.;
   // EMC Corporation; Symantec 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 20 
Line 29 
 // //
 //============================================================================== //==============================================================================
 // //
 // Author: Mike Brasher (mbrasher@bmc.com)  
 //  
 // Modified By:  
 //  
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #include "CIMQualifier.h" #include "CIMQualifier.h"
 #include "Indentor.h"  #include "CIMQualifierRep.h"
 #include "DeclContext.h"  
 #include "CIMName.h" #include "CIMName.h"
 #include "Exception.h"  #include "InternalException.h"
 #include "XmlWriter.h"  #include "StrLit.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
   PEGASUS_USING_STD;
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 41 
Line 46 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   CIMQualifierRep::CIMQualifierRep(const CIMQualifierRep& x) :
       Sharable(),
       _name(x._name),
       _value(x._value),
       _flavor(x._flavor),
       _propagated(x._propagated),
       _ownerCount(0)
   {
       // Set the CIM name tag.
       _nameTag = generateCIMNameTag(_name);
   }
   
 CIMQualifierRep::CIMQualifierRep( CIMQualifierRep::CIMQualifierRep(
     const String& name,      const CIMName& name,
     const CIMValue& value,     const CIMValue& value,
     Uint32 flavor,      const CIMFlavor & flavor,
     Boolean propagated)     Boolean propagated)
     :     :
     _name(name),     _name(name),
     _value(value),     _value(value),
     _flavor(flavor),     _flavor(flavor),
     _propagated(propagated)      _propagated(propagated),
       _ownerCount(0)
 { {
     if (!CIMName::legal(name))      // ensure name is not null
         throw IllegalName();      if (name.isNull())
   
     if (_value.getType() == CIMType::NONE)  
         throw NullType();  
 }  
   
 CIMQualifierRep::~CIMQualifierRep()  
 { {
           throw UninitializedObjectException();
 } }
       // Set the CIM name tag.
 void CIMQualifierRep::setName(const String& name)      _nameTag = generateCIMNameTag(_name);
 {  
     if (!CIMName::legal(name))  
         throw IllegalName();  
   
     _name = name;  
 } }
  
 static const char* _toString(Boolean x)  CIMQualifierRep::~CIMQualifierRep()
 { {
     return x ? "true" : "false";  
 } }
  
 void CIMQualifierRep::toXml(Array<Sint8>& out) const  void CIMQualifierRep::setName(const CIMName& name)
 { {
     out << "<QUALIFIER";      // ensure name is not null
     out << " NAME=\"" << _name << "\"";      if (name.isNull())
     out << " TYPE=\"" << TypeToString(_value.getType()) << "\"";  
   
     if (_propagated != false)  
         out << " PROPAGATED=\"" << _toString(_propagated) << "\"";  
   
     FlavorToXml(out, _flavor);  
   
     out << ">\n";  
   
     _value.toXml(out);  
   
     out << "</QUALIFIER>\n";  
 }  
   
 void CIMQualifierRep::print(PEGASUS_STD(ostream) &os) const  
 { {
     Array<Sint8> tmp;          throw UninitializedObjectException();
     toXml(tmp);  
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 } }
  
 /** toMof Generates MOF output for a qualifier.      if (_ownerCount != 0 && _name != name)
     The BNF for this is:  
     <pre>  
     qualifier          = qualifierName [ qualifierParameter ] [ ":" 1*flavor]  
   
     qualifierParameter = "(" constantValue ")" | arrayInitializer  
   
     arrayInitializer   = "{" constantValue*( "," constantValue)"}"  
     </pre>  
 */  
 void CIMQualifierRep::toMof(Array<Sint8>& out) const   //ATTNKS:  
 {  
     // Output Qualifier name  
     out << _name;  
   
     /* If the qualifier is Boolean, we do not put out a value. This is  
        the way MOF is shown.  Note that we should really be checking  
        the qualifierdecl to compare with the default but the defaults  
        on the current ones are all false so the existence of the qualifier  
        implies true.  
        Also if the value is Null, we do not put out a value because  
        no value has been set.  Assumes that qualifiers are built  
        with NULL set if no value has been placed in the qualifier.  
     */  
     Boolean hasValueField = false;  
     if (!_value.isNull() || !(_value.getType() == CIMType::BOOLEAN) )  
     {     {
         out << " (";          MessageLoaderParms parms(
         hasValueField = true;              "Common.CIMQualifierRep.CONTAINED_QUALIFIER_NAMECHANGEDEXCEPTION",
         _value.toMof(out);              "Attempted to change the name of a qualifier"
                   " already in a container.");
           throw Exception(parms);
     }     }
  
     // output the flavors      _name = name;
     // ATTNKS: This is a poor test to see if flavor output exists  
     String flavorString;  
     flavorString = FlavorToMof(_flavor);  
     if (flavorString.size())  
     {  
         if (hasValueField == false)  
             out << " (";  
         out << " : ";  
         out << flavorString;  
         hasValueField = true;  
         //FlavorToMof(out, _flavor);  
     }  
  
     if (hasValueField)      // Set the CIM name tag.
         out << ")";      _nameTag = generateCIMNameTag(_name);
 } }
  
 CIMQualifierRep::CIMQualifierRep()  void CIMQualifierRep::resolveFlavor (
       const CIMFlavor & inheritedFlavor,
       Boolean inherited)
 { {
       // ATTN: KS P3 Needs more tests and expansion so we treate first different
       // from inheritance
  
       // if the turnoff flags set, reset the flavor bits
       if (inheritedFlavor.hasFlavor (CIMFlavor::RESTRICTED))
       {
           _flavor.removeFlavor (CIMFlavor::TOSUBCLASS);
           _flavor.removeFlavor (CIMFlavor::TOINSTANCE);
 } }
       if (inheritedFlavor.hasFlavor (CIMFlavor::DISABLEOVERRIDE))
 CIMQualifierRep::CIMQualifierRep(const CIMQualifierRep& x) :  
     Sharable(),  
     _name(x._name),  
     _value(x._value),  
     _flavor(x._flavor),  
     _propagated(x._propagated)  
 { {
           _flavor.removeFlavor (CIMFlavor::ENABLEOVERRIDE);
 } }
  
 CIMQualifierRep& CIMQualifierRep::operator=(const CIMQualifierRep& x)      _flavor.addFlavor (inheritedFlavor);
 {  
     return *this;  
 } }
  
 Boolean CIMQualifierRep::identical(const CIMQualifierRep* x) const Boolean CIMQualifierRep::identical(const CIMQualifierRep* x) const
 { {
     return     return
         this == x ||         this == x ||
         CIMName::equal(_name, x->_name) &&          _name.equal(x->_name) &&
         _value == x->_value &&         _value == x->_value &&
         _flavor == x->_flavor &&          (_flavor.equal (x->_flavor)) &&
         _propagated == x->_propagated;         _propagated == x->_propagated;
 } }
  
 void CIMQualifierRep::setValue(const CIMValue& value) void CIMQualifierRep::setValue(const CIMValue& value)
 { {
     _value = value;     _value = value;
   
     if (_value.getType() == CIMType::NONE)  
         throw NullType();  
 } }
  
 PEGASUS_NAMESPACE_END PEGASUS_NAMESPACE_END

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