(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.8 and 1.44

version 1.8, 2001/06/16 23:10:03 version 1.44, 2007/04/11 04:17:47
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;
  
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
Line 41 
Line 49 
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   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)
 { {
     if (!CIMName::legal(name))      // ensure name is not null
         throw IllegalName();      if (name.isNull())
       {
     if (_value.getType() == CIMType::NONE)          throw UninitializedObjectException();
         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);
           out.append('"');
       }
  
     FlavorToXml(out, _flavor);      XmlWriter::appendQualifierFlavorEntity(out, _flavor);
  
     out << ">\n";      out << STRLIT(">\n");
  
     _value.toXml(out);      XmlWriter::appendValueElement(out, _value);
  
     out << "</QUALIFIER>\n";      out << STRLIT("</QUALIFIER>\n");
 } }
  
 void CIMQualifierRep::print(PEGASUS_STD(ostream) &os) const  /** toMof Generates MOF output for a qualifier.
 {      The BNF for this is:
     Array<Sint8> tmp;      <pre>
     toXml(tmp);      qualifier          = qualifierName [ qualifierParameter ] [ ":" 1*flavor]
     tmp.append('\0');  
     os << tmp.getData() << PEGASUS_STD(endl);  
 }  
  
 CIMQualifierRep::CIMQualifierRep()      qualifierParameter = "(" constantValue ")" | arrayInitializer
   
       arrayInitializer   = "{" constantValue*( "," constantValue)"}"
       </pre>
   */
   void CIMQualifierRep::toMof(Buffer& 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 << STRLIT(" (false)");
 } }
           else
 CIMQualifierRep::CIMQualifierRep(const CIMQualifierRep& x) :  
     Sharable(),  
     _name(x._name),  
     _value(x._value),  
     _flavor(x._flavor),  
     _propagated(x._propagated)  
 { {
               if( !_value.isArray() )
                   out << STRLIT(" (");
               else
                   out << STRLIT(" ");
               hasValueField = true;
               MofWriter::appendValueElement(out, _value);
               if( !_value.isArray() )
                   out.append(')');
           }
 } }
  
 CIMQualifierRep& CIMQualifierRep::operator=(const CIMQualifierRep& x)      // output the flavors
       String flavorString;
       flavorString = MofWriter::getQualifierFlavor(_flavor);
       if (flavorString.size())
 { {
     return *this;          out << STRLIT(" : ");
           out << flavorString;
 } }
   }
   
  
 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.8  
changed lines
  Added in v.1.44
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2