(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.13 and 1.43

version 1.13, 2002/03/08 01:53:03 version 1.43, 2006/11/10 18:14:57
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 "CIMQualifierRep.h"
 #include "Indentor.h" #include "Indentor.h"
 #include "DeclContext.h"  
 #include "CIMName.h" #include "CIMName.h"
 #include "Exception.h"  #include "InternalException.h"
 #include "XmlWriter.h" #include "XmlWriter.h"
   #include "MofWriter.h"
   #include "StrLit.h"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
 PEGASUS_USING_STD; PEGASUS_USING_STD;
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // CIMQualifierRep // CIMQualifierRep
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   CIMQualifierRep::CIMQualifierRep()
   {
   }
   
   CIMQualifierRep::CIMQualifierRep(const CIMQualifierRep& x) :
       Sharable(),
       _name(x._name),
       _value(x._value),
       _flavor(x._flavor),
       _propagated(x._propagated)
   {
   }
   
 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),
Line 52 
Line 73 
     _flavor(flavor),     _flavor(flavor),
     _propagated(propagated)     _propagated(propagated)
 { {
       // ensure name is not null
     //cout << "KSTEST create qualifier " << name << " flavor " << flavor      if (name.isNull())
     //    << " Propogated " << propagated << endl;      {
     if (!CIMName::legal(name))          throw UninitializedObjectException();
         throw IllegalName();      }
   
     if (_value.getType() == CIMType::NONE)  
         throw NullType();  
 } }
  
 CIMQualifierRep::~CIMQualifierRep() CIMQualifierRep::~CIMQualifierRep()
 { {
   
 } }
  
 void CIMQualifierRep::setName(const String& name)  void CIMQualifierRep::setName(const CIMName& name)
 { {
     if (!CIMName::legal(name))      // ensure name is not null
         throw IllegalName();      if (name.isNull())
       {
           throw UninitializedObjectException();
       }
  
     _name = name;     _name = name;
 } }
  
   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))
       {
           _flavor.removeFlavor (CIMFlavor::ENABLEOVERRIDE);
       }
   
       _flavor.addFlavor (inheritedFlavor);
   }
   
 static const char* _toString(Boolean x) static const char* _toString(Boolean x)
 { {
     return x ? "true" : "false";     return x ? "true" : "false";
 } }
  
 void CIMQualifierRep::toXml(Array<Sint8>& out) const  void CIMQualifierRep::toXml(Buffer& out) const
 { {
     out << "<QUALIFIER";      out << STRLIT("<QUALIFIER NAME=\"") << _name;
     out << " NAME=\"" << _name << "\"";      out.append('"');
     out << " TYPE=\"" << TypeToString(_value.getType()) << "\"";      out << STRLIT(" TYPE=\"") << cimTypeToString(_value.getType ());
       out.append('"');
  
     if (_propagated != false)     if (_propagated != false)
         out << " PROPAGATED=\"" << _toString(_propagated) << "\"";      {
           out << STRLIT(" PROPAGATED=\"") << _toString(_propagated);
     FlavorToXml(out, _flavor);          out.append('"');
       }
  
     out << ">\n";      XmlWriter::appendQualifierFlavorEntity(out, _flavor);
  
     /* While property Null XML is to be printed without the value tag      out << STRLIT(">\n");
        the specification requires that Qualifer NULL values include the  
        value tag  
        KSTESTNULL  
     */  
     _value.toXml(out, true);  
  
     out << "</QUALIFIER>\n";      XmlWriter::appendValueElement(out, _value);
 }  
  
 void CIMQualifierRep::print(PEGASUS_STD(ostream) &os) const      out << STRLIT("</QUALIFIER>\n");
 {  
     Array<Sint8> tmp;  
     toXml(tmp);  
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 } }
  
 /** toMof Generates MOF output for a qualifier. /** toMof Generates MOF output for a qualifier.
Line 121 
Line 153 
     arrayInitializer   = "{" constantValue*( "," constantValue)"}"     arrayInitializer   = "{" constantValue*( "," constantValue)"}"
     </pre>     </pre>
 */ */
 void CIMQualifierRep::toMof(Array<Sint8>& out) const   //ATTNKS:  void CIMQualifierRep::toMof(Buffer& out) const
 { {
     // Output Qualifier name     // Output Qualifier name
     out << _name;     out << _name;
  
     /* If the qualifier is Boolean, we do not put out a value. This is     /* 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 way MOF is shown.  Note that we should really be checking
        the qualifierdecl to compare with the default but the defaults         the qualifierdecl to compare with the default.
        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        Also if the value is Null, we do not put out a value because
        no value has been set.  Assumes that qualifiers are built        no value has been set.  Assumes that qualifiers are built
        with NULL set if no value has been placed in the qualifier.        with NULL set if no value has been placed in the qualifier.
     */     */
     Boolean hasValueField = false;     Boolean hasValueField = false;
     if (!_value.isNull() || !(_value.getType() == CIMType::BOOLEAN) )      if (!_value.isNull())
       {
           if (_value.getType() == CIMTYPE_BOOLEAN)
     {     {
         out << " (";              Boolean b;
               _value.get(b);
               if (!b)
                   out << STRLIT(" (false)");
           }
           else
           {
               out << STRLIT(" (");
         hasValueField = true;         hasValueField = true;
         _value.toMof(out);              MofWriter::appendValueElement(out, _value);
               out.append(')');
           }
     }     }
  
     // output the flavors     // output the flavors
     // ATTNKS: This is a poor test to see if flavor output exists  
     String flavorString;     String flavorString;
     flavorString = FlavorToMof(_flavor);      flavorString = MofWriter::getQualifierFlavor(_flavor);
     if (flavorString.size())     if (flavorString.size())
     {     {
         if (hasValueField == false)          out << STRLIT(" : ");
             out << " (";  
         out << " : ";  
         out << flavorString;         out << flavorString;
         hasValueField = true;  
         //FlavorToMof(out, _flavor);  
     }     }
   
     if (hasValueField)  
         out << ")";  
 } }
  
 CIMQualifierRep::CIMQualifierRep()  
 {  
   
 }  
   
 CIMQualifierRep::CIMQualifierRep(const CIMQualifierRep& x) :  
     Sharable(),  
     _name(x._name),  
     _value(x._value),  
     _flavor(x._flavor),  
     _propagated(x._propagated)  
 {  
   
 }  
   
 CIMQualifierRep& CIMQualifierRep::operator=(const CIMQualifierRep& x)  
 {  
     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.13  
changed lines
  Added in v.1.43
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2