(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.7 and 1.35

version 1.7, 2001/06/16 17:30:37 version 1.35, 2004/10/17 20:39:17
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%2004////////////////////////////////////////////////////////////////////////
 // //
 // 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.
 // //
 // 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 22 
Line 27 
 // //
 // Author: Mike Brasher (mbrasher@bmc.com) // Author: Mike Brasher (mbrasher@bmc.com)
 // //
 // Modified By:  // Modified By: Carol Ann Krug Graves, Hewlett-Packard Company
   //                (carolann_graves@hp.com)
 // //
 //%///////////////////////////////////////////////////////////////////////////// //%/////////////////////////////////////////////////////////////////////////////
  
 #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"
  
 PEGASUS_NAMESPACE_BEGIN PEGASUS_NAMESPACE_BEGIN
   PEGASUS_USING_STD;
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 42 
Line 50 
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
 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 60 
     _flavor(flavor),     _flavor(flavor),
     _propagated(propagated)     _propagated(propagated)
 { {
     if (!CIMName::legal(name))  
         throw IllegalName();  
   
     if (_value.getType() == CIMType::NONE)  
         throw NullType();  
 } }
  
 CIMQualifierRep::~CIMQualifierRep() CIMQualifierRep::~CIMQualifierRep()
Line 64 
Line 67 
  
 } }
  
 void CIMQualifierRep::setName(const String& name)  void CIMQualifierRep::setName(const CIMName& name)
 { {
     if (!CIMName::legal(name))  
         throw IllegalName();  
   
     _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";
Line 81 
Line 102 
 { {
     out << "<QUALIFIER";     out << "<QUALIFIER";
     out << " NAME=\"" << _name << "\"";     out << " NAME=\"" << _name << "\"";
     out << " TYPE=\"" << TypeToString(_value.getType()) << "\"";      out << " TYPE=\"" << cimTypeToString (_value.getType ()) << "\"";
  
     if (_propagated != false)     if (_propagated != false)
         out << " PROPAGATED=\"" << _toString(_propagated) << "\"";         out << " PROPAGATED=\"" << _toString(_propagated) << "\"";
  
     FlavorToXml(out, _flavor);      XmlWriter::appendQualifierFlavorEntity(out, _flavor);
  
     out << ">\n";     out << ">\n";
  
     _value.toXml(out);      XmlWriter::appendValueElement(out, _value);
  
     out << "</QUALIFIER>\n";     out << "</QUALIFIER>\n";
 } }
  
 void CIMQualifierRep::print(PEGASUS_STD(ostream) &os) const  /** toMof Generates MOF output for a qualifier.
       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
   {
       // 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.
          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())
       {
              if (_value.getType() == CIMTYPE_BOOLEAN)
              {
                       Boolean b;
                           _value.get(b);
                       if(!b)
                                   out << " (false)";
              }
              else
              {
                      out << " (";
                      hasValueField = true;
                      MofWriter::appendValueElement(out, _value);
                      out << ")";
              }
       }
   
       // output the flavors
       String flavorString;
       flavorString = MofWriter::getQualifierFlavor(_flavor);
       if (flavorString.size())
 { {
     Array<Sint8> tmp;                  out << " : ";
     toXml(tmp);                  out << flavorString;
     tmp.append('\0');      }
     os << tmp.getData() << PEGASUS_STD(endl);  
 } }
  
   
 CIMQualifierRep::CIMQualifierRep() CIMQualifierRep::CIMQualifierRep()
 { {
  
Line 118 
Line 183 
  
 } }
  
 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.7  
changed lines
  Added in v.1.35
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2