(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.53.2.1

version 1.13, 2002/03/08 01:53:03 version 1.53.2.1, 2013/06/03 22:35:12
Line 1 
Line 1 
 //%/////////////////////////////////////////////////////////////////////////////  //%LICENSE////////////////////////////////////////////////////////////////
 //  
 // Copyright (c) 2000, 2001 The Open group, BMC Software, Tivoli Systems, IBM  
 //  
 // Permission is hereby granted, free of charge, to any person obtaining a copy  
 // of this software and associated documentation files (the "Software"), to  
 // deal in the Software without restriction, including without limitation the  
 // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or  
 // sell copies of the Software, and to permit persons to whom the Software is  
 // furnished to do so, subject to the following conditions:  
 //  
 // THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN  
 // ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED  
 // "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT  
 // LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR  
 // PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT  
 // HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN  
 // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION  
 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.  
 // //
 //==============================================================================  // Licensed to The Open Group (TOG) under one or more contributor license
   // agreements.  Refer to the OpenPegasusNOTICE.txt file distributed with
   // this work for additional information regarding copyright ownership.
   // Each contributor licenses this file to you under the OpenPegasus Open
   // Source License; you may not use this file except in compliance with the
   // License.
   //
   // Permission is hereby granted, free of charge, to any person obtaining a
   // copy of this software and associated documentation files (the "Software"),
   // to deal in the Software without restriction, including without limitation
   // the rights to use, copy, modify, merge, publish, distribute, sublicense,
   // and/or sell copies of the Software, and to permit persons to whom the
   // Software is furnished to do so, subject to the following conditions:
   //
   // The above copyright notice and this permission notice shall be included
   // in all copies or substantial portions of the Software.
   //
   // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
   // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
   // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
   // IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
   // CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
   // TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
   // SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 // //
 // 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; PEGASUS_USING_STD;
   
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
 // //
 // CIMQualifierRep // CIMQualifierRep
 // //
 //////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
  
   CIMQualifierRep::CIMQualifierRep(const CIMQualifierRep& x) :
       _name(x._name),
       _value(x._value),
       _flavor(x._flavor),
       _propagated(x._propagated),
       _nameTag(x._nameTag),
       _refCounter(1),
       _ownerCount(0)
   {
   }
   
 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),
       _refCounter(1),
       _ownerCount(0)
 { {
       // ensure name is not null
     //cout << "KSTEST create qualifier " << name << " flavor " << flavor      if (name.isNull())
     //    << " Propogated " << propagated << endl;  
     if (!CIMName::legal(name))  
         throw IllegalName();  
   
     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)  void CIMQualifierRep::setName(const CIMName& name)
 { {
     return x ? "true" : "false";      // ensure name is not null
 }      if (name.isNull())
   
 void CIMQualifierRep::toXml(Array<Sint8>& out) const  
 { {
     out << "<QUALIFIER";          throw UninitializedObjectException();
     out << " NAME=\"" << _name << "\"";  
     out << " TYPE=\"" << TypeToString(_value.getType()) << "\"";  
   
     if (_propagated != false)  
         out << " PROPAGATED=\"" << _toString(_propagated) << "\"";  
   
     FlavorToXml(out, _flavor);  
   
     out << ">\n";  
   
     /* While property Null XML is to be printed without the value tag  
        the specification requires that Qualifer NULL values include the  
        value tag  
        KSTESTNULL  
     */  
     _value.toXml(out, true);  
   
     out << "</QUALIFIER>\n";  
 } }
  
 void CIMQualifierRep::print(PEGASUS_STD(ostream) &os) const      if (_ownerCount != 0 && _name != name)
 { {
     Array<Sint8> tmp;          MessageLoaderParms parms(
     toXml(tmp);              "Common.CIMQualifierRep.CONTAINED_QUALIFIER_NAMECHANGEDEXCEPTION",
     tmp.append('\0');              "Attempted to change the name of a qualifier"
     os << tmp.getData() << PEGASUS_STD(endl);                  " already in a container.");
           throw Exception(parms);
 } }
  
 /** toMof Generates MOF output for a qualifier.      _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      // Set the CIM name tag.
        the way MOF is shown.  Note that we should really be checking      _nameTag = generateCIMNameTag(_name);
        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 << " (";  
         hasValueField = true;  
         _value.toMof(out);  
     }     }
  
     // output the flavors  void CIMQualifierRep::resolveFlavor(const CIMFlavor & inheritedFlavor)
     // ATTNKS: This is a poor test to see if flavor output exists  
     String flavorString;  
     flavorString = FlavorToMof(_flavor);  
     if (flavorString.size())  
     {     {
         if (hasValueField == false)      // ATTN: KS P3 Needs more tests and expansion so we treate first different
             out << " (";      // from inheritance
         out << " : ";  
         out << flavorString;  
         hasValueField = true;  
         //FlavorToMof(out, _flavor);  
     }  
   
     if (hasValueField)  
         out << ")";  
 }  
  
 CIMQualifierRep::CIMQualifierRep()      // 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)  
 {  
     _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.53.2.1
No CVS admin address has been configured
 Powered by
ViewCVS 0.9.2